1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qmfhelpers_p.h"

    43 #include "qmessagemanager.h"

    44 

    45 #include <QRegExp>

    46 

    47 

    48 QTM_BEGIN_NAMESPACE

    49 

    50 namespace {

    51 

    52 quint64 messageStatusMask(const QString &field)

    53 {

    54     QMessageManager mgr;

    55     return QmfHelpers::convert(mgr)->messageStatusMask(field);

    56 }

    57 

    58 }

    59 

    60 namespace QmfHelpers {

    61 

    62 QString stripIdentifierPrefix(const QString &s)

    63 {

    64     return s.mid(4);

    65 }

    66     

    67 QString prefixIdentifier(const QString &s)

    68 {

    69     return "QMF_" + s;

    70 }

    71     

    72 QMessageId convert(const QMailMessageId &id)

    73 {

    74     return QMessageId(prefixIdentifier(QString::number(id.toULongLong())));

    75 }

    76 

    77 QMailMessageId convert(const QMessageId &id)

    78 {

    79     return QMailMessageId(stripIdentifierPrefix(id.toString()).toULongLong());

    80 }

    81 

    82 QMessageAccountId convert(const QMailAccountId &id)

    83 {

    84     return QMessageAccountId(prefixIdentifier(QString::number(id.toULongLong())));

    85 }

    86 

    87 QMailAccountId convert(const QMessageAccountId &id)

    88 {

    89     return QMailAccountId(stripIdentifierPrefix(id.toString()).toULongLong());

    90 }

    91 

    92 QMessageFolderId convert(const QMailFolderId &id)

    93 {

    94     return QMessageFolderId(prefixIdentifier(QString::number(id.toULongLong())));

    95 }

    96 

    97 QMailFolderId convert(const QMessageFolderId &id)

    98 {

    99     return QMailFolderId(stripIdentifierPrefix(id.toString()).toULongLong());

   100 }

   101 

   102 /* in qmessagecontentcontainerid_qmf.cpp

   103 QMessageContentContainerId convert(const QMailMessagePart::Location &location);

   104 

   105 QMailMessagePart::Location convert(const QMessageContentContainerId &id);

   106 

   107 QMessageContentContainerId bodyId(const QMailMessageId &id);

   108 */

   109 

   110 QMessageIdList convert(const QList<QMailMessageId> &ids)

   111 {

   112     QMessageIdList result;

   113 

   114     foreach (const QMailMessageId &id, ids) {

   115         result.append(convert(id));

   116     }

   117 

   118     return result;

   119 }

   120 

   121 QList<QMailMessageId> convert(const QMessageIdList &ids)

   122 {

   123     QList<QMailMessageId> result;

   124 

   125     foreach (const QMessageId &id, ids) {

   126         result.append(convert(id));

   127     }

   128 

   129     return result;

   130 }

   131 

   132 QMessageAccountIdList convert(const QList<QMailAccountId> &ids)

   133 {

   134     QMessageAccountIdList result;

   135 

   136     foreach (const QMailAccountId &id, ids) {

   137         result.append(convert(id));

   138     }

   139 

   140     return result;

   141 }

   142 

   143 QList<QMailAccountId> convert(const QMessageAccountIdList &ids)

   144 {

   145     QList<QMailAccountId> result;

   146 

   147     foreach (const QMessageAccountId &id, ids) {

   148         result.append(convert(id));

   149     }

   150 

   151     return result;

   152 }

   153 

   154 QMessageFolderIdList convert(const QList<QMailFolderId> &ids)

   155 {

   156     QMessageFolderIdList result;

   157 

   158     foreach (const QMailFolderId &id, ids) {

   159         result.append(convert(id));

   160     }

   161 

   162     return result;

   163 }

   164 

   165 QList<QMailFolderId> convert(const QMessageFolderIdList &ids)

   166 {

   167     QList<QMailFolderId> result;

   168 

   169     foreach (const QMessageFolderId &id, ids) {

   170         result.append(convert(id));

   171     }

   172 

   173     return result;

   174 }

   175 

   176 QMessageContentContainerIdList convert(const QList<QMailMessagePart::Location> &locations)

   177 {

   178     QMessageContentContainerIdList result;

   179 

   180     foreach (const QMailMessagePart::Location &location, locations) {

   181         result.append(convert(location));

   182     }

   183 

   184     return result;

   185 }

   186 

   187 /*

   188 QList<QMailMessagePart::Location> convert(const QMessageContentContainerIdList &ids)

   189 {

   190     QList<QMailMessagePart::Location> result;

   191 

   192     foreach (const QMessageContentContainerId &id, ids) {

   193         result.append(convert(id));

   194     }

   195 

   196     return result;

   197 }

   198 */

   199 

   200 QMailMessage::MessageType convert(QMessage::Type t)

   201 {

   202     QMailMessage::MessageType result(QMailMessage::None);

   203 

   204     // This could be a single value or a mask

   205     if (t & QMessage::Mms) {

   206         result = static_cast<QMailMessage::MessageType>(result | QMailMessage::Mms);

   207     }

   208     if (t & QMessage::Sms) {

   209         result = static_cast<QMailMessage::MessageType>(result | QMailMessage::Sms);

   210     }

   211     if (t & QMessage::Email) {

   212         result = static_cast<QMailMessage::MessageType>(result | QMailMessage::Email);

   213     }

   214     if (t & QMessage::InstantMessage) {

   215         result = static_cast<QMailMessage::MessageType>(result | QMailMessage::Instant);

   216     }

   217 

   218     return result;

   219 }

   220 

   221 QMessage::Type convert(QMailMessage::MessageType t)

   222 {

   223     QMessage::Type result(QMessage::NoType);

   224 

   225     // This could be a single value or a mask

   226     if (t & QMailMessage::Mms) {

   227         result = static_cast<QMessage::Type>(static_cast<uint>(result | QMessage::Mms));

   228     }

   229     if (t & QMailMessage::Sms) {

   230         result = static_cast<QMessage::Type>(static_cast<uint>(result | QMessage::Sms));

   231     }

   232     if (t & QMailMessage::Email) {

   233         result = static_cast<QMessage::Type>(static_cast<uint>(result | QMessage::Email));

   234     }

   235     if (t & QMailMessage::Instant) {

   236         result = static_cast<QMessage::Type>(static_cast<uint>(result | QMessage::InstantMessage));

   237     }

   238 

   239     return result;

   240 }

   241 

   242 QMailMessage::MessageType convert(QMessage::TypeFlags v)

   243 {

   244     return convert(static_cast<QMessage::Type>(static_cast<uint>(v)));

   245 }

   246 

   247 /*

   248 QMailStore::ErrorCode convert(QMessageManager::Error v)

   249 {

   250     switch (v) {

   251     case QMessageManager::InvalidId: return QMailStore::InvalidId;

   252     case QMessageManager::ConstraintFailure: return QMailStore::ConstraintFailure;

   253     case QMessageManager::ContentInaccessible: return QMailStore::ContentInaccessible;

   254     case QMessageManager::NotYetImplemented: return QMailStore::NotYetImplemented;

   255     case QMessageManager::FrameworkFault: return QMailStore::FrameworkFault;

   256     default: break;

   257     }

   258 

   259     return QMailStore::NoError;

   260 }

   261 */

   262 

   263 QMessageManager::Error convert(QMailStore::ErrorCode v)

   264 {

   265     switch (v) {

   266     case QMailStore::InvalidId: return QMessageManager::InvalidId;

   267     case QMailStore::ConstraintFailure: return QMessageManager::ConstraintFailure;

   268     case QMailStore::ContentInaccessible: return QMessageManager::ContentInaccessible;

   269     case QMailStore::NotYetImplemented: return QMessageManager::NotYetImplemented;

   270     case QMailStore::FrameworkFault: return QMessageManager::FrameworkFault;

   271     default: break;

   272     }

   273 

   274     return QMessageManager::NoError;

   275 }

   276 

   277 QMailStore::MessageRemovalOption convert(QMessageManager::RemovalOption v)

   278 {

   279     switch (v) {

   280     case QMessageManager::RemoveOnOriginatingServer: return QMailStore::CreateRemovalRecord;

   281     default: break;

   282     }

   283 

   284     return QMailStore::NoRemovalRecord;

   285 }

   286 

   287 /*

   288 QMessageManager::RemovalOption convert(QMailStore::MessageRemovalOption v)

   289 {

   290     switch (v) {

   291     case QMailStore::CreateRemovalRecord: return QMessageManager::RemoveOnOriginatingServer;

   292     default: break;

   293     }

   294 

   295     return QMessageManager::RemoveLocalCopyOnly;

   296 }

   297 */

   298 

   299 QMailServiceAction::Activity convert(QMessageService::State v)

   300 {

   301     switch (v) {

   302     case QMessageService::InactiveState: return QMailServiceAction::Pending;

   303     case QMessageService::ActiveState: return QMailServiceAction::InProgress;

   304     case QMessageService::CanceledState: return QMailServiceAction::Failed;

   305     case QMessageService::FinishedState: return QMailServiceAction::Successful;

   306     default: break;

   307     }

   308 

   309     return QMailServiceAction::Pending;

   310 }

   311 

   312 QMessageService::State convert(QMailServiceAction::Activity v)

   313 {

   314     switch (v) {

   315     case QMailServiceAction::Pending: return QMessageService::InactiveState;

   316     case QMailServiceAction::InProgress: return QMessageService::ActiveState;

   317     case QMailServiceAction::Successful: return QMessageService::FinishedState;

   318     case QMailServiceAction::Failed: return QMessageService::FinishedState;

   319     default: break;

   320     }

   321 

   322     return QMessageService::InactiveState;

   323 }

   324 

   325 QMessage::StatusFlags convert(quint64 v)

   326 {

   327     QMessage::StatusFlags result(0);

   328 

   329     if (v & (QMailMessage::Read | QMailMessage::ReadElsewhere)) {

   330         result |= QMessage::Read;

   331     }

   332     if (v & QMailMessage::HasAttachments) {

   333         result |= QMessage::HasAttachments;

   334     }

   335     if (v & QMailMessage::Incoming) {

   336         result |= QMessage::Incoming;

   337     }

   338     if (v & QMailMessage::Removed) {

   339         result |= QMessage::Removed;

   340     }

   341 

   342     return result;

   343 }

   344 

   345 quint64 convert(QMessage::Status v)

   346 {

   347     // We cannot rely on the QMailMessage status masks until the store has been initialized

   348     static QMailStore *store = QMailStore::instance();

   349     Q_UNUSED(store);

   350 

   351     quint64 result(0);

   352 

   353     if (v & QMessage::Read) {

   354         result |= QMailMessage::Read;

   355     }

   356     if (v & QMessage::HasAttachments) {

   357         result |= QMailMessage::HasAttachments;

   358     }

   359     if (v & QMessage::Incoming) {

   360         result |= QMailMessage::Incoming;

   361     }

   362     if (v & QMessage::Removed) {

   363         result |= QMailMessage::Removed;

   364     }

   365 

   366     return result;

   367 }

   368 

   369 quint64 convert(QMessage::StatusFlags v)

   370 {

   371     return convert(static_cast<QMessage::Status>(static_cast<uint>(v)));

   372 }

   373 

   374 QMessageAddress convert(const QMailAddress &address)

   375 {

   376     QString addr(address.toString());

   377     if (!addr.isEmpty()) {

   378         QMessageAddress::Type type(QMessageAddress::Email);

   379 

   380         QRegExp suffix("\\s+\\(TYPE=(\\w*)\\)$");

   381         int index = suffix.indexIn(addr);

   382         if (index != -1) {

   383             addr = addr.left(addr.length() - suffix.cap(0).length());

   384 

   385             QString spec(suffix.cap(1));

   386             if (spec == "System") {

   387                 type = QMessageAddress::System;

   388             } else if (spec == "Phone") {

   389                 type = QMessageAddress::Phone;

   390             } else if (spec == "InstantMessage") {

   391                 type = QMessageAddress::InstantMessage;

   392             }

   393         }

   394 

   395         return QMessageAddress(type, addr);

   396     }

   397 

   398     return QMessageAddress();

   399 }

   400 

   401 QMailAddress convert(const QMessageAddress &address)

   402 {

   403     QString suffix;

   404     if (address.type() == QMessageAddress::System) {

   405         suffix = " (TYPE=System)";

   406     } else if (address.type() == QMessageAddress::Phone) {

   407         suffix = " (TYPE=Phone)";

   408     } else if (address.type() == QMessageAddress::InstantMessage) {

   409         suffix = " (TYPE=InstantMessage)";

   410     }

   411 

   412     return QMailAddress(address.addressee() + suffix);

   413 }

   414 

   415 QMessageAddressList convert(const QList<QMailAddress> &list)

   416 {

   417     QList<QMessageAddress> result;

   418 

   419     foreach (const QMailAddress &address, list) {

   420         result.append(convert(address));

   421     }

   422 

   423     return result;

   424 }

   425 

   426 QList<QMailAddress> convert(const QMessageAddressList& list)

   427 {

   428     QList<QMailAddress> result;

   429 

   430     foreach (const QMessageAddress &address, list) {

   431         result.append(convert(address));

   432     }

   433 

   434     return result;

   435 }

   436 

   437 /*

   438 QMessageDataComparator::EqualityComparator convert(QMailDataComparator::EqualityComparator cmp)

   439 {

   440     switch (cmp)

   441     {

   442     case QMailDataComparator::Equal: return QMessageDataComparator::Equal;

   443     case QMailDataComparator::NotEqual: return QMessageDataComparator::NotEqual;

   444     default: break;

   445     }

   446 

   447     return QMessageDataComparator::Equal;

   448 }

   449 */

   450 

   451 QMailDataComparator::EqualityComparator convert(QMessageDataComparator::EqualityComparator cmp)

   452 {

   453     switch (cmp)

   454     {

   455     case QMessageDataComparator::Equal: return QMailDataComparator::Equal;

   456     case QMessageDataComparator::NotEqual: return QMailDataComparator::NotEqual;

   457     default: break;

   458     }

   459 

   460     return QMailDataComparator::Equal;

   461 }

   462 

   463 /*

   464 QMessageDataComparator::InclusionComparator convert(QMailDataComparator::InclusionComparator cmp)

   465 {

   466     switch (cmp)

   467     {

   468     case QMailDataComparator::Includes: return QMessageDataComparator::Includes;

   469     case QMailDataComparator::Excludes: return QMessageDataComparator::Excludes;

   470     default: break;

   471     }

   472     

   473     return QMessageDataComparator::Includes;

   474 }

   475 */

   476 

   477 QMailDataComparator::InclusionComparator convert(QMessageDataComparator::InclusionComparator cmp)

   478 {

   479     switch (cmp)

   480     {

   481     case QMessageDataComparator::Includes: return QMailDataComparator::Includes;

   482     case QMessageDataComparator::Excludes: return QMailDataComparator::Excludes;

   483     default: break;

   484     }

   485 

   486     return QMailDataComparator::Includes;

   487 }

   488 

   489 /*

   490 QMessageDataComparator::RelationComparator convert(QMailDataComparator::RelationComparator cmp)

   491 {

   492     switch (cmp)

   493     {

   494     case QMailDataComparator::LessThan: return QMessageDataComparator::LessThan;

   495     case QMailDataComparator::LessThanEqual: return QMessageDataComparator::LessThanEqual;

   496     case QMailDataComparator::GreaterThan: return QMessageDataComparator::GreaterThan;

   497     case QMailDataComparator::GreaterThanEqual: return QMessageDataComparator::GreaterThanEqual;

   498     default: break;

   499     }

   500     

   501     return QMessageDataComparator::LessThan;

   502 }

   503 */

   504 

   505 QMailDataComparator::RelationComparator convert(QMessageDataComparator::RelationComparator cmp)

   506 {

   507     switch (cmp)

   508     {

   509     case QMessageDataComparator::LessThan: return QMailDataComparator::LessThan;

   510     case QMessageDataComparator::LessThanEqual: return QMailDataComparator::LessThanEqual;

   511     case QMessageDataComparator::GreaterThan: return QMailDataComparator::GreaterThan;

   512     case QMessageDataComparator::GreaterThanEqual: return QMailDataComparator::GreaterThanEqual;

   513     default: break;

   514     }

   515 

   516     return QMailDataComparator::LessThan;

   517 }

   518 

   519 /* in qmessageaccountfilterkey_qmf.cpp

   520 QMessageAccountFilter convert(const QMailAccountKey &key);

   521 QMailAccountKey convert(const QMessageAccountFilter &filter);

   522 */

   523 

   524 /* in qmessagefolderfilterkey_qmf.cpp

   525 QMessageFolderFilter convert(const QMailFolderKey &key);

   526 QMailFolderKey convert(const QMessageFolderFilter &filter);

   527 */

   528 

   529 /* in qmessagefilterkey_qmf.cpp

   530 QMessageFilter convert(const QMailMessageKey &key);

   531 QMailMessageKey convert(const QMessageFilter &filter);

   532 */

   533 

   534 /* in qmessageaccountsortkey_qmf.cpp

   535 QMessageAccountSortOrder convert(const QMailAccountSortKey &key);

   536 QMailAccountSortKey convert(const QMessageAccountSortOrder &sortOrder);

   537 */

   538 

   539 /* in qmessagefoldersortkey_qmf.cpp

   540 QMessageFolderSortOrder convert(const QMailFolderSortKey &key);

   541 QMailFolderSortKey convert(const QMessageFolderSortOrder &sortOrder);

   542 */

   543 

   544 /* in qmessagesortkey_qmf.cpp

   545 QMessageSortOrder convert(const QMailMessageSortKey &key);

   546 QMailMessageSortKey convert(const QMessageSortOrder &sortOrder);

   547 */

   548 

   549 /* in qmessageaccount_qmf.cpp

   550 QMessageAccount convert(const QMailAccount &account);

   551 QMailAccount convert(const QMessageAccount &account);

   552 */

   553 

   554 /* in qmessagefolder_qmf.cpp

   555 QMessageFolder convert(const QMailFolder &folder);

   556 QMailFolder convert(const QMessageFolder &folder);

   557 */

   558 

   559 /* in qmessage_qmf.cpp

   560 QMessage convert(const QMailMessage &message);

   561 QMailMessage convert(const QMessage &message);

   562 QMailMessage* convert(QMessage *message);

   563 */

   564 

   565 /* in qmessagestore_qmf.cpp

   566 QMailStore *convert(QMessageStore *store);

   567 QMailStore *convert(QMessageManager &manager);

   568 */

   569 

   570 quint64 highPriorityMask()

   571 {

   572     static quint64 mask(messageStatusMask("QMessage::HighPriority"));

   573     return mask;

   574 }

   575 

   576 quint64 lowPriorityMask()

   577 {

   578     static quint64 mask(messageStatusMask("QMessage::LowPriority"));

   579     return mask;

   580 }

   581 

   582 }

   583 

   584 bool operator==(const QMailMessagePart::Location &lhs, const QMailMessagePart::Location &rhs)

   585 {

   586     return (lhs.toString(true) == rhs.toString(true));

   587 }

   588 

   589 

   590 QTM_END_NAMESPACE