1 /*

     2  * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description:

    15  *

    16  */

    17 

    18 #include "nmapimailboxsettingsdata_p.h"

    19 

    20 #include <nmapimailboxsettingsdata.h>

    21 #include <QObject>

    22 #include <QVariant>

    23 #include <QString>

    24 #include <QHash>

    25 #include "emailtrace.h"

    26 

    27 namespace EmailClientApi

    28 {

    29 

    30 NmApiMailboxSettingsDataPrivate::NmApiMailboxSettingsDataPrivate() :

    31     mId(0), mSettings(new QHash<int, QVariant>())

    32 {

    33     NM_FUNCTION;

    34     Q_CHECK_PTR( mSettings );

    35 }

    36 

    37 NmApiMailboxSettingsDataPrivate::~NmApiMailboxSettingsDataPrivate()

    38 {

    39     NM_FUNCTION;

    40 }

    41 

    42 /*!

    43  \fn setMailboxId 

    44  \param mailboxId - valid mailbox id as quint64.

    45  

    46  Sets the mailbox id               

    47  */

    48 void NmApiMailboxSettingsDataPrivate::setMailboxId(quint64 mailboxId)

    49 {

    50     NM_FUNCTION;

    51     mId = mailboxId;

    52 }

    53 

    54 /*!

    55  \fn mailboxId

    56  \return quint64 - the mailbox id.

    57  

    58  Gets the mailbox id.              

    59  */

    60 quint64 NmApiMailboxSettingsDataPrivate::mailboxId() const

    61 {

    62     NM_FUNCTION;

    63     return mId;

    64 }

    65 

    66 /*!

    67  \fn setValue 

    68  \param key - setting data to be set.

    69  \param settingValue - Value to be set as QVariant.

    70 

    71  Sets individual setting value.        

    72  */

    73 void NmApiMailboxSettingsDataPrivate::setValue(int key, const QVariant &settingValue)

    74 {

    75     NM_FUNCTION;

    76     (*mSettings)[key] = settingValue;

    77 }

    78 

    79 /*!

    80  \fn getValue

    81  \param key - setting data to get.

    82  \param settingValue - On return holds as QVariant.

    83  \return true if succesfull, false otherwise.

    84  

    85  Get individual setting value.        

    86  */

    87 bool NmApiMailboxSettingsDataPrivate::getValue(int key, QVariant &settingValue) const

    88 {

    89     NM_FUNCTION;

    90     if (mSettings->contains(key)) {

    91         settingValue = (*mSettings)[key];

    92         return true;

    93     }

    94     return false;

    95 }

    96 

    97 /*!

    98  \fn validateString

    99  \param key - setting data to validate.

   100  \param val - value to validate.

   101  \param validated - if this key was validated by the method

   102  \return true if valid value, false otherwise.

   103  

   104  validates individual string type value.        

   105  */

   106 bool NmApiMailboxSettingsDataPrivate::validateString(int key, QVariant& val, bool& validated) const

   107 {

   108     NM_FUNCTION;

   109     bool ret = true;

   110     switch (key) {     

   111      case OutgoingPassword:

   112      case IncomingPassword:     

   113      case FolderPath: 

   114      case IncomingLoginName:

   115      case MailboxName:

   116      case MyName:

   117      case ReceptionActiveProfile:

   118      case IncomingMailServer:

   119      case OutgoingMailServer:

   120      case OutgoingLoginName:

   121      case EmailAddress:

   122      case ReplyAddress:

   123      case EmailAlias:               

   124      case IncomingMailUsesAuthentication:

   125      case OutgoingMailUsesAuthentication:

   126      case IncomingMailSecurityType:

   127      case OutgoingMailSecurityType:

   128      case EmailNotificationState:         

   129      case AlwaysOnlineState:{

   130          validated=true;

   131          if (val.type() != QVariant::String) {

   132              ret = false;

   133              break;

   134          }

   135 

   136          QString sz = val.toString();                   

   137          ret = validateStringValue(key, sz);

   138          break;

   139      }

   140          

   141      default: {

   142          validated = false;

   143          ret = false;

   144          break;

   145          }

   146     }    

   147     return ret;

   148 }

   149 

   150 /*!

   151  \fn validateStringValue

   152  \param key - setting data to validate.

   153  \param val - value to validate. 

   154  \return true if valid value, false otherwise.

   155  

   156  validates individual string type value.        

   157  */

   158 bool NmApiMailboxSettingsDataPrivate::validateStringValue(int key, QString& val) const

   159 {

   160     NM_FUNCTION;

   161     int ret = true;

   162     bool valid = true, validated = false;

   163     

   164     valid = validateStringGeneral(key ,val, validated);

   165     if (validated && !valid) {

   166             ret = false;

   167     }

   168     

   169     if( !validated ) {

   170         valid = validateEmailAddress(key ,val, validated);

   171         if (validated && !valid) {

   172             ret = false;

   173         }

   174     }

   175     

   176     if( !validated ) {

   177         valid = validateUsesAuthentication(key ,val, validated);

   178         if (validated && !valid) {

   179             ret = false;

   180         }

   181     }

   182     

   183     if( !validated ) {

   184         valid = validateSecurityType(key ,val, validated);

   185         if (validated && !valid) {

   186             ret = false;

   187         }

   188     }

   189     

   190     if( !validated ) {

   191         valid = validateAOLState(key ,val, validated);

   192         if (validated && !valid) {

   193             ret = false;

   194         }

   195     }        

   196     return ret;

   197 }

   198 

   199 /*!

   200  \fn validateStringGeneral

   201  \param key - setting data to validate.

   202  \param val - value to validate.

   203  \param handled - true if method value was handled by method.

   204  \return true if valid value, false otherwise.

   205  

   206  validates individual string type value.        

   207  */

   208 bool NmApiMailboxSettingsDataPrivate::validateStringGeneral(int key, QString& /*val*/, bool& handled) const

   209 {

   210     NM_FUNCTION;

   211     int ret = true;

   212     switch (key) {     

   213          case OutgoingPassword:

   214          case IncomingPassword:     

   215          case FolderPath:

   216          case IncomingLoginName:

   217          case MailboxName:

   218          case MyName:

   219          case ReceptionActiveProfile:

   220          case IncomingMailServer:

   221          case OutgoingMailServer:

   222          case OutgoingLoginName: {

   223              // Allready validated that values are string, 

   224              // otherwise method is not called

   225              handled = true;         

   226              break;

   227          }

   228          default: {

   229              handled = false;

   230              ret = false;

   231              break;

   232          }    

   233     } 

   234     return ret;

   235 }

   236          

   237 /*!

   238  \fn validateEmailAddress

   239  \param key - setting data to validate.

   240  \param val - value to validate.

   241  \param handled - true if value was validated by the method

   242  \return true if valid value, false otherwise.

   243  

   244  validates individual string type value.        

   245  */

   246 bool NmApiMailboxSettingsDataPrivate::validateEmailAddress(int key, QString& val, bool& handled) const

   247 {

   248     NM_FUNCTION;

   249     int ret = true;

   250     switch (key) {        

   251         case EmailAddress:

   252         case ReplyAddress: {

   253             handled = true;

   254             if (val.size() == 0) {             

   255                  ret = false;

   256                  break;

   257             }

   258             if (!(val.contains("@"))) {

   259                ret = false;

   260             }

   261             break;

   262         }

   263         case EmailAlias:  {

   264             handled = true;            

   265             break;

   266         }

   267         default: {

   268             handled = false;

   269             ret = false;

   270             break;

   271         }

   272     }

   273     return ret;

   274 }

   275      

   276 /*!

   277  \fn validateUsesAuthentication

   278  \param key - setting data to validate.

   279  \param val - value to validate.

   280  \param handled - true if value was validated by the method

   281  \return true if valid value, false otherwise.

   282  

   283  validates individual string type value.        

   284  */

   285 bool NmApiMailboxSettingsDataPrivate::validateUsesAuthentication(int key, QString& val, bool& handled) const

   286 { 

   287     NM_FUNCTION;

   288     int ret = true;

   289     switch (key) { 

   290         case IncomingMailUsesAuthentication:

   291         case OutgoingMailUsesAuthentication: {

   292             handled = true;

   293             if (val.size() == 0) {

   294                 ret = false;

   295                 break;

   296             }

   297             if (!(val.contains("none") ||

   298               val.contains("UserAuthentication") ||

   299                   (key == OutgoingMailUsesAuthentication &&

   300                    val.contains("SameAsIncoming")) )) {

   301                 ret = false;

   302             }

   303             break;

   304         }

   305         default: {

   306             handled = false;

   307             ret = false;

   308             break;

   309         }

   310     }

   311     return ret;

   312 }

   313         

   314 /*!

   315  \fn validateSecurityType

   316  \param key - setting data to validate.

   317  \param val - value to validate.

   318  \param validated - true if value was validated by the method

   319  \return true if valid value, false otherwise.

   320  

   321  validates individual string type value.        

   322  */

   323 bool NmApiMailboxSettingsDataPrivate::validateSecurityType(int key, QString& val, bool& handled) const

   324 { 

   325     NM_FUNCTION;

   326     int ret = true;

   327     switch (key) {

   328          case IncomingMailSecurityType:

   329          case OutgoingMailSecurityType: {

   330             handled = true;

   331             if (val.size() == 0) {

   332                 ret = false;

   333                 break;

   334             }

   335             if (!(val.contains("StartTls") || 

   336                   val.contains("SSLTls") || 

   337                   val.contains("none"))) {

   338                 ret = false;

   339             }

   340             break;

   341          }

   342          default: {

   343              handled = false;

   344              ret = false;

   345              break;

   346          }

   347      }

   348      return ret;

   349 }

   350 

   351 /*!

   352  \fn validateAOLState

   353  \param key - setting data to validate.

   354  \param val - value to validate.

   355  \param validated - true if value was validated by the method

   356  \return true if valid value, false otherwise.

   357  

   358  validates individual string type value.        

   359  */

   360 bool NmApiMailboxSettingsDataPrivate::validateAOLState(int key, QString& val, bool& handled) const

   361 { 

   362     NM_FUNCTION;

   363     int ret = true;

   364     switch (key) {

   365         case EmailNotificationState:         

   366         case AlwaysOnlineState:{

   367          handled = true;

   368          if (val.size() == 0) {

   369               ret = false;

   370               break;

   371           }

   372           if (!( (val.contains("always") && key == AlwaysOnlineState) || 

   373                  (val.contains("automatic") && key == EmailNotificationState) || 

   374                   val.contains("homeOnly") || 

   375                   val.contains("off"))) {

   376               ret = false;

   377           }

   378           break;

   379         }

   380         default: {

   381             handled = false;

   382             ret = false;

   383             break;

   384         }

   385     }

   386     return ret;

   387 }

   388 

   389 /*!

   390  \fn validateInteger

   391  \param key - setting data to validate.

   392  \param val - value to validate.

   393  \param validated - true if value was validated by the method

   394  \return true if valid value, false otherwise.

   395  

   396  validates individual integer type value.        

   397  */

   398 bool NmApiMailboxSettingsDataPrivate::validateInteger(int key, QVariant& val, bool& validated) const

   399 {

   400     NM_FUNCTION;

   401     bool ret = true;

   402     switch (key) { 

   403         case DownloadPictures:

   404         case MessageDivider:

   405         case UserNameHidden:

   406         case FirstEmnReceived:

   407         case EmnReceivedNotSynced:

   408         case AoLastUpdateFailed:

   409         case AoUpdateSuccessfulWithCurSettings:

   410         case ReceptionUserDefinedProfile:

   411         case ReceptionInboxSyncWindow:

   412         case ReceptionGenericSyncWindowInMessages:

   413         case IncomingPort:

   414         case OutgoingPort:

   415         case ReceptionWeekDays:

   416         case ReceptionDayStartTime:

   417         case ReceptionDayEndTime:

   418         case ReceptionRefreshPeriodDayTime:

   419         case ReceptionRefreshPeriodOther: {

   420             validated = true;

   421             if (!(val.type() == QVariant::Int ||

   422                   val.type() == QVariant::UInt ||

   423                   val.type() == QVariant::LongLong  ||

   424                   val.type() == QVariant::ULongLong ||

   425                   val.type() == QVariant::Double)) {

   426                 ret = false;

   427                 break;

   428             }            

   429             int ival = val.toInt();

   430             ret = validateIntVal(key,ival);

   431             break;

   432         }

   433         default: {

   434             validated = false;

   435             ret = false;

   436             break;

   437         }

   438      }

   439      return ret;

   440 }

   441 

   442 /*!

   443  \fn validateIntVal

   444  \param key - setting data to validate.

   445  \param val - value to validate. 

   446  \return true if valid value, false otherwise.

   447  

   448  validates individual integer type value.        

   449  */

   450 bool NmApiMailboxSettingsDataPrivate::validateIntVal(int key, int val) const

   451 {

   452     NM_FUNCTION;

   453     int ret = true;

   454     bool valid = true, validated = false;

   455 

   456     valid = validateIntGeneral(key ,val, validated);

   457     if (validated && !valid) {

   458            ret = false;

   459     }

   460     

   461     if( !validated ) {

   462        valid = validateOnOffValue(key ,val, validated);

   463        if (validated && !valid) {

   464            ret = false;

   465        }

   466     }

   467     

   468     if( !validated ) {

   469        valid = validateWeekdayMask(key ,val, validated);

   470        if (validated && !valid) {

   471            ret = false;

   472        }

   473     }

   474     

   475     if( !validated ) {

   476        valid = validateHoursInDay(key ,val, validated);

   477        if (validated && !valid) {

   478            ret = false;

   479        }

   480     }

   481     return ret;

   482 }

   483 

   484 /*!

   485  \fn validateOnOffValue

   486  \param key - setting data to validate.

   487  \param val - value to validate.

   488  \param validated - true if value was validated by the method

   489  \return true if valid value, false otherwise.

   490  

   491  validates individual integer type value.        

   492  */

   493 bool NmApiMailboxSettingsDataPrivate::validateOnOffValue(int key, int val, bool& handled) const

   494 {

   495     NM_FUNCTION;

   496     bool ret = true;

   497     switch (key) {   

   498         // Integer: 0=Off, 1=On    

   499         case DownloadPictures:

   500         case MessageDivider:

   501         case UserNameHidden:

   502         

   503         // Integer: 0=false,1=true

   504         case FirstEmnReceived:

   505         case EmnReceivedNotSynced:

   506         case AoLastUpdateFailed:

   507         case AoUpdateSuccessfulWithCurSettings:

   508         

   509         // Integer: 0=Disabled, 1=Enabled

   510         case ReceptionUserDefinedProfile: {

   511             handled = true;

   512             if (!(0 <= val && val <= 1)) {

   513                 ret = false;

   514             }

   515             break;

   516         }

   517         default: {

   518             handled = false;

   519             ret = false;

   520             break;

   521         }

   522     }

   523     return ret;

   524 }

   525 

   526 /*!

   527  \fn validateIntGeneral

   528  \param key - setting data to validate.

   529  \param val - value to validate.

   530  \param validated - true if value was validated by the method

   531  \return true if valid value, false otherwise.

   532  

   533  validates individual integer type value.        

   534  */

   535 bool NmApiMailboxSettingsDataPrivate::validateIntGeneral(int key, int /*val*/, bool& handled) const

   536 { 

   537     NM_FUNCTION;

   538     bool ret = true;

   539     switch (key) {         

   540         // Integer: 5,15,60,240,0="When open mailbox"

   541         case ReceptionRefreshPeriodDayTime:

   542         case ReceptionRefreshPeriodOther:

   543             

   544         // Integer: 0=All messages

   545         case ReceptionInboxSyncWindow:

   546         case ReceptionGenericSyncWindowInMessages:

   547             

   548         // Integer

   549         case IncomingPort:

   550         case OutgoingPort: {

   551             // Allready valid thate these are integers

   552             handled = true;

   553             break;

   554         }

   555         default: {

   556             handled = false;

   557             ret = false;

   558             break;

   559         }

   560     }

   561     return ret;

   562 }

   563 

   564 /*!

   565  \fn validateWeekDayMask

   566  \param key - setting data to validate.

   567  \param val - value to validate.

   568  \param validated - true if value was validated by the method

   569  \return true if valid value, false otherwise.

   570  

   571  validates individual integer type value.        

   572  */

   573 bool NmApiMailboxSettingsDataPrivate::validateWeekdayMask(int key, int val, bool& handled) const

   574 {

   575     NM_FUNCTION;

   576     bool ret = true;

   577     switch (key) {

   578         // Integer bitmask of weekdays: 0x01=Mon,0x02=Tue,0x04=Wed,0x08=Thu,0x10=Fri,0x20=Sat,0x40=Sun

   579         case ReceptionWeekDays: {

   580             handled = true;

   581             int wkdmask = Mon | Tue | Wed | Thu | Fri | Sat | Sun;

   582             if ((val & wkdmask) != val) {

   583                 ret = false;

   584             }

   585             break;

   586         }

   587         default: {

   588             handled = false;

   589             ret = false;

   590             break;

   591         }

   592     }

   593     return ret;

   594 }

   595 

   596 /*!

   597  \fn validateHoursInDay

   598  \param key - setting data to validate.

   599  \param val - value to validate.

   600  \param validated - true if value was validated by the method

   601  \return true if valid value, false otherwise.

   602  

   603  validates individual integer type value.        

   604  */

   605 bool NmApiMailboxSettingsDataPrivate::validateHoursInDay(int key, int val, bool& handled) const

   606 { 

   607     NM_FUNCTION;

   608     bool ret = true;

   609     switch (key) {

   610         // Integer: 0-23

   611         case ReceptionDayStartTime:

   612         case ReceptionDayEndTime: {

   613             handled = true;

   614             if (!(0 <= val && val <= 23)) { 

   615                 ret = false;

   616             }

   617             break;

   618         }

   619         default: {

   620             handled = false;

   621             ret = false;

   622             break;

   623         }

   624     }

   625     return ret;

   626 }

   627 

   628 /*!

   629  \fn validateBool

   630  \param key - setting data to validate.

   631  \param val - value to validate.

   632  \param validated - true if value was validated by the method

   633  \return true if valid value, false otherwise.

   634  

   635  validates individual bool type value.        

   636  */

   637 bool NmApiMailboxSettingsDataPrivate::validateBool(int key, QVariant& val, bool& validated) const

   638 {

   639     NM_FUNCTION;

   640     bool ret = true;

   641     switch (key) {    

   642         

   643         // Boolean

   644         case IncomingSecureSockets:

   645         case IncomingSSLWrapper:

   646         case UseOutgoingAuthentication:

   647         case OutgoingSecureSockets:

   648         case OutgoingSSLWrapper: {

   649             validated = true;

   650             if (val.type() != QVariant::Bool)

   651                 ret = false;

   652             break;

   653         }

   654         default: {

   655             validated = false;

   656             ret = false;

   657             break;

   658         }

   659     }

   660     return ret;

   661 }

   662 

   663 /*!

   664  \fn validateDateTime

   665  \param key - setting data to validate.

   666  \param val - value to validate.

   667  \param validated - true if value was validated by the method

   668  \return true if valid value, false otherwise.

   669  

   670  validates individual QDateTime type value.        

   671  */

   672 bool NmApiMailboxSettingsDataPrivate::validateDateTime(int key, QVariant& val, bool& validated) const

   673 {

   674     NM_FUNCTION;

   675     switch(key) {

   676         case AoLastSuccessfulUpdate: {

   677             if (val.type() != QVariant::DateTime) {

   678                 validated = true;

   679                 return false;

   680             }

   681             return true;

   682         }

   683         default: {

   684             validated = false;

   685             return false;

   686         }

   687     }

   688 }

   689 

   690 /*!

   691  \fn validateData

   692  \return boolean - true, everything validated OK, false otherwise

   693  

   694  Validates data in this container. 

   695  */   

   696 bool NmApiMailboxSettingsDataPrivate::validateData() const

   697 {

   698     NM_FUNCTION;

   699     QHash<int, QVariant>::const_iterator i = mSettings->constBegin();

   700     while (i != mSettings->constEnd()) {

   701         

   702         bool validated = false;

   703         bool valid = false;        

   704         

   705         int key = i.key();

   706         QVariant val = i.value();

   707         

   708         ++i;

   709         

   710         valid = validateString(key ,val, validated);

   711         if (validated) {

   712             if (!valid){

   713                 return valid;

   714             }

   715             continue;

   716         }

   717         

   718         valid = validateInteger(key ,val, validated);

   719         if (validated) {

   720             if (!valid){

   721                 return valid;

   722             }

   723             continue;

   724         }

   725          

   726         valid = validateBool(key ,val, validated);

   727         if (validated) {

   728             if (!valid){

   729                 return valid;

   730             }

   731             continue;

   732         } 

   733          

   734         valid = validateDateTime(key ,val, validated);

   735         if (validated) {

   736             if (!valid){

   737                 return valid;

   738             }

   739             continue;

   740         }

   741      }

   742      return true;

   743 }

   744 

   745 QList<int> NmApiMailboxSettingsDataPrivate::listSettings() const

   746 {

   747     NM_FUNCTION;

   748     return mSettings->keys();

   749 }

   750 

   751 /*!

   752  \fn clearSettings 

   753  

   754  Resets data in this container. 

   755  */

   756 void NmApiMailboxSettingsDataPrivate::clearSettings()

   757 {

   758 	mSettings->clear();

   759 }

   760 

   761 }//end namespace