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 "nmapiheaders.h"

    19 

    20 

    21 

    22 

    23 namespace EmailClientApi

    24 {

    25 

    26 NmApiMailboxSettingsDataPrivate::NmApiMailboxSettingsDataPrivate() :

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

    28 {

    29     NM_FUNCTION;

    30     Q_CHECK_PTR( mSettings );

    31 }

    32 

    33 NmApiMailboxSettingsDataPrivate::~NmApiMailboxSettingsDataPrivate()

    34 {

    35     NM_FUNCTION;

    36 }

    37 

    38 /*!

    39  \fn setMailboxId 

    40  \param mailboxId - valid mailbox id as quint64.

    41  

    42  Sets the mailbox id               

    43  */

    44 void NmApiMailboxSettingsDataPrivate::setMailboxId(quint64 mailboxId)

    45 {

    46     NM_FUNCTION;

    47     mId = mailboxId;

    48 }

    49 

    50 /*!

    51  \fn mailboxId

    52  \return quint64 - the mailbox id.

    53  

    54  Gets the mailbox id.              

    55  */

    56 quint64 NmApiMailboxSettingsDataPrivate::mailboxId() const

    57 {

    58     NM_FUNCTION;

    59     return mId;

    60 }

    61 

    62 /*!

    63  \fn setValue 

    64  \param key - setting data to be set.

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

    66 

    67  Sets individual setting value.        

    68  */

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

    70 {

    71     NM_FUNCTION;

    72     (*mSettings)[key] = settingValue;

    73 }

    74 

    75 /*!

    76  \fn getValue

    77  \param key - setting data to get.

    78  \param settingValue - On return holds as QVariant.

    79  \return true if succesfull, false otherwise.

    80  

    81  Get individual setting value.        

    82  */

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

    84 {

    85     NM_FUNCTION;

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

    87         settingValue = (*mSettings)[key];

    88         return true;

    89     }

    90     return false;

    91 }

    92 

    93 /*!

    94  \fn validateString

    95  \param key - setting data to validate.

    96  \param val - value to validate.

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

    98  \return true if valid value, false otherwise.

    99  

   100  validates individual string type value.        

   101  */

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

   103 {

   104     NM_FUNCTION;

   105     bool ret = true;

   106     switch (key) {     

   107      case OutgoingPassword:

   108      case IncomingPassword:     

   109      case FolderPath: 

   110      case IncomingLoginName:

   111      case MailboxName:

   112      case MyName:

   113      case ReceptionActiveProfile:

   114      case IncomingMailServer:

   115      case OutgoingMailServer:

   116      case OutgoingLoginName:

   117      case EmailAddress:

   118      case ReplyAddress:

   119      case EmailAlias:               

   120      case IncomingMailUsesAuthentication:

   121      case OutgoingMailUsesAuthentication:

   122      case IncomingMailSecurityType:

   123      case OutgoingMailSecurityType:

   124      case EmailNotificationState:         

   125      case AlwaysOnlineState:{

   126          validated=true;

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

   128              ret = false;

   129              break;

   130          }

   131 

   132          QString sz = val.toString();                   

   133          ret = validateStringValue(key, sz);

   134          break;

   135      }

   136          

   137      default: {

   138          validated = false;

   139          ret = false;

   140          break;

   141          }

   142     }    

   143     return ret;

   144 }

   145 

   146 /*!

   147  \fn validateStringValue

   148  \param key - setting data to validate.

   149  \param val - value to validate. 

   150  \return true if valid value, false otherwise.

   151  

   152  validates individual string type value.        

   153  */

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

   155 {

   156     NM_FUNCTION;

   157     int ret = true;

   158     bool valid = true, validated = false;

   159     

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

   161     if (validated && !valid) {

   162             ret = false;

   163     }

   164     

   165     if( !validated ) {

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

   167         if (validated && !valid) {

   168             ret = false;

   169         }

   170     }

   171     

   172     if( !validated ) {

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

   174         if (validated && !valid) {

   175             ret = false;

   176         }

   177     }

   178     

   179     if( !validated ) {

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

   181         if (validated && !valid) {

   182             ret = false;

   183         }

   184     }

   185     

   186     if( !validated ) {

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

   188         if (validated && !valid) {

   189             ret = false;

   190         }

   191     }        

   192     return ret;

   193 }

   194 

   195 /*!

   196  \fn validateStringGeneral

   197  \param key - setting data to validate.

   198  \param val - value to validate.

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

   200  \return true if valid value, false otherwise.

   201  

   202  validates individual string type value.        

   203  */

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

   205 {

   206     NM_FUNCTION;

   207     int ret = true;

   208     switch (key) {     

   209          case OutgoingPassword:

   210          case IncomingPassword:     

   211          case FolderPath:

   212          case IncomingLoginName:

   213          case MailboxName:

   214          case MyName:

   215          case ReceptionActiveProfile:

   216          case IncomingMailServer:

   217          case OutgoingMailServer:

   218          case OutgoingLoginName: {

   219              // Allready validated that values are string, 

   220              // otherwise method is not called

   221              handled = true;         

   222              break;

   223          }

   224          default: {

   225              handled = false;

   226              ret = false;

   227              break;

   228          }    

   229     } 

   230     return ret;

   231 }

   232          

   233 /*!

   234  \fn validateEmailAddress

   235  \param key - setting data to validate.

   236  \param val - value to validate.

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

   238  \return true if valid value, false otherwise.

   239  

   240  validates individual string type value.        

   241  */

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

   243 {

   244     NM_FUNCTION;

   245     int ret = true;

   246     switch (key) {        

   247         case EmailAddress:

   248         case ReplyAddress: {

   249             handled = true;

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

   251                  ret = false;

   252                  break;

   253             }

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

   255                ret = false;

   256             }

   257             break;

   258         }

   259         case EmailAlias:  {

   260             handled = true;            

   261             break;

   262         }

   263         default: {

   264             handled = false;

   265             ret = false;

   266             break;

   267         }

   268     }

   269     return ret;

   270 }

   271      

   272 /*!

   273  \fn validateUsesAuthentication

   274  \param key - setting data to validate.

   275  \param val - value to validate.

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

   277  \return true if valid value, false otherwise.

   278  

   279  validates individual string type value.        

   280  */

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

   282 { 

   283     NM_FUNCTION;

   284     int ret = true;

   285     switch (key) { 

   286         case IncomingMailUsesAuthentication:

   287         case OutgoingMailUsesAuthentication: {

   288             handled = true;

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

   290                 ret = false;

   291                 break;

   292             }

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

   294               val.contains("UserAuthentication") ||

   295                   (key == OutgoingMailUsesAuthentication &&

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

   297                 ret = false;

   298             }

   299             break;

   300         }

   301         default: {

   302             handled = false;

   303             ret = false;

   304             break;

   305         }

   306     }

   307     return ret;

   308 }

   309         

   310 /*!

   311  \fn validateSecurityType

   312  \param key - setting data to validate.

   313  \param val - value to validate.

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

   315  \return true if valid value, false otherwise.

   316  

   317  validates individual string type value.        

   318  */

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

   320 { 

   321     NM_FUNCTION;

   322     int ret = true;

   323     switch (key) {

   324          case IncomingMailSecurityType:

   325          case OutgoingMailSecurityType: {

   326             handled = true;

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

   328                 ret = false;

   329                 break;

   330             }

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

   332                   val.contains("SSLTls") || 

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

   334                 ret = false;

   335             }

   336             break;

   337          }

   338          default: {

   339              handled = false;

   340              ret = false;

   341              break;

   342          }

   343      }

   344      return ret;

   345 }

   346 

   347 /*!

   348  \fn validateAOLState

   349  \param key - setting data to validate.

   350  \param val - value to validate.

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

   352  \return true if valid value, false otherwise.

   353  

   354  validates individual string type value.        

   355  */

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

   357 { 

   358     NM_FUNCTION;

   359     int ret = true;

   360     switch (key) {

   361         case EmailNotificationState:         

   362         case AlwaysOnlineState:{

   363          handled = true;

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

   365               ret = false;

   366               break;

   367           }

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

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

   370                   val.contains("homeOnly") || 

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

   372               ret = false;

   373           }

   374           break;

   375         }

   376         default: {

   377             handled = false;

   378             ret = false;

   379             break;

   380         }

   381     }

   382     return ret;

   383 }

   384 

   385 /*!

   386  \fn validateInteger

   387  \param key - setting data to validate.

   388  \param val - value to validate.

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

   390  \return true if valid value, false otherwise.

   391  

   392  validates individual integer type value.        

   393  */

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

   395 {

   396     NM_FUNCTION;

   397     bool ret = true;

   398     switch (key) { 

   399         case DownloadPictures:

   400         case MessageDivider:

   401         case UserNameHidden:

   402         case FirstEmnReceived:

   403         case EmnReceivedNotSynced:

   404         case AoLastUpdateFailed:

   405         case AoUpdateSuccessfulWithCurSettings:

   406         case ReceptionUserDefinedProfile:

   407         case ReceptionInboxSyncWindow:

   408         case ReceptionGenericSyncWindowInMessages:

   409         case IncomingPort:

   410         case OutgoingPort:

   411         case ReceptionWeekDays:

   412         case ReceptionDayStartTime:

   413         case ReceptionDayEndTime:

   414         case ReceptionRefreshPeriodDayTime:

   415         case ReceptionRefreshPeriodOther: {

   416             validated = true;

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

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

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

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

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

   422                 ret = false;

   423                 break;

   424             }            

   425             int ival = val.toInt();

   426             ret = validateIntVal(key,ival);

   427             break;

   428         }

   429         default: {

   430             validated = false;

   431             ret = false;

   432             break;

   433         }

   434      }

   435      return ret;

   436 }

   437 

   438 /*!

   439  \fn validateIntVal

   440  \param key - setting data to validate.

   441  \param val - value to validate. 

   442  \return true if valid value, false otherwise.

   443  

   444  validates individual integer type value.        

   445  */

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

   447 {

   448     NM_FUNCTION;

   449     int ret = true;

   450     bool valid = true, validated = false;

   451 

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

   453     if (validated && !valid) {

   454            ret = false;

   455     }

   456     

   457     if( !validated ) {

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

   459        if (validated && !valid) {

   460            ret = false;

   461        }

   462     }

   463     

   464     if( !validated ) {

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

   466        if (validated && !valid) {

   467            ret = false;

   468        }

   469     }

   470     

   471     if( !validated ) {

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

   473        if (validated && !valid) {

   474            ret = false;

   475        }

   476     }

   477     return ret;

   478 }

   479 

   480 /*!

   481  \fn validateOnOffValue

   482  \param key - setting data to validate.

   483  \param val - value to validate.

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

   485  \return true if valid value, false otherwise.

   486  

   487  validates individual integer type value.        

   488  */

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

   490 {

   491     NM_FUNCTION;

   492     bool ret = true;

   493     switch (key) {   

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

   495         case DownloadPictures:

   496         case MessageDivider:

   497         case UserNameHidden:

   498         

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

   500         case FirstEmnReceived:

   501         case EmnReceivedNotSynced:

   502         case AoLastUpdateFailed:

   503         case AoUpdateSuccessfulWithCurSettings:

   504         

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

   506         case ReceptionUserDefinedProfile: {

   507             handled = true;

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

   509                 ret = false;

   510             }

   511             break;

   512         }

   513         default: {

   514             handled = false;

   515             ret = false;

   516             break;

   517         }

   518     }

   519     return ret;

   520 }

   521 

   522 /*!

   523  \fn validateIntGeneral

   524  \param key - setting data to validate.

   525  \param val - value to validate.

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

   527  \return true if valid value, false otherwise.

   528  

   529  validates individual integer type value.        

   530  */

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

   532 { 

   533     NM_FUNCTION;

   534     bool ret = true;

   535     switch (key) {         

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

   537         case ReceptionRefreshPeriodDayTime:

   538         case ReceptionRefreshPeriodOther:

   539             

   540         // Integer: 0=All messages

   541         case ReceptionInboxSyncWindow:

   542         case ReceptionGenericSyncWindowInMessages:

   543             

   544         // Integer

   545         case IncomingPort:

   546         case OutgoingPort: {

   547             // Allready valid thate these are integers

   548             handled = true;

   549             break;

   550         }

   551         default: {

   552             handled = false;

   553             ret = false;

   554             break;

   555         }

   556     }

   557     return ret;

   558 }

   559 

   560 /*!

   561  \fn validateWeekDayMask

   562  \param key - setting data to validate.

   563  \param val - value to validate.

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

   565  \return true if valid value, false otherwise.

   566  

   567  validates individual integer type value.        

   568  */

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

   570 {

   571     NM_FUNCTION;

   572     bool ret = true;

   573     switch (key) {

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

   575         case ReceptionWeekDays: {

   576             handled = true;

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

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

   579                 ret = false;

   580             }

   581             break;

   582         }

   583         default: {

   584             handled = false;

   585             ret = false;

   586             break;

   587         }

   588     }

   589     return ret;

   590 }

   591 

   592 /*!

   593  \fn validateHoursInDay

   594  \param key - setting data to validate.

   595  \param val - value to validate.

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

   597  \return true if valid value, false otherwise.

   598  

   599  validates individual integer type value.        

   600  */

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

   602 { 

   603     NM_FUNCTION;

   604     bool ret = true;

   605     switch (key) {

   606         // Integer: 0-23

   607         case ReceptionDayStartTime:

   608         case ReceptionDayEndTime: {

   609             handled = true;

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

   611                 ret = false;

   612             }

   613             break;

   614         }

   615         default: {

   616             handled = false;

   617             ret = false;

   618             break;

   619         }

   620     }

   621     return ret;

   622 }

   623 

   624 /*!

   625  \fn validateBool

   626  \param key - setting data to validate.

   627  \param val - value to validate.

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

   629  \return true if valid value, false otherwise.

   630  

   631  validates individual bool type value.        

   632  */

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

   634 {

   635     NM_FUNCTION;

   636     bool ret = true;

   637     switch (key) {    

   638         

   639         // Boolean

   640         case IncomingSecureSockets:

   641         case IncomingSSLWrapper:

   642         case UseOutgoingAuthentication:

   643         case OutgoingSecureSockets:

   644         case OutgoingSSLWrapper: {

   645             validated = true;

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

   647                 ret = false;

   648             break;

   649         }

   650         default: {

   651             validated = false;

   652             ret = false;

   653             break;

   654         }

   655     }

   656     return ret;

   657 }

   658 

   659 /*!

   660  \fn validateDateTime

   661  \param key - setting data to validate.

   662  \param val - value to validate.

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

   664  \return true if valid value, false otherwise.

   665  

   666  validates individual QDateTime type value.        

   667  */

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

   669 {

   670     NM_FUNCTION;

   671     switch(key) {

   672         case AoLastSuccessfulUpdate: {

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

   674                 validated = true;

   675                 return false;

   676             }

   677             return true;

   678         }

   679         default: {

   680             validated = false;

   681             return false;

   682         }

   683     }

   684 }

   685 

   686 /*!

   687  \fn validateData

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

   689  

   690  Validates data in this container. 

   691  */   

   692 bool NmApiMailboxSettingsDataPrivate::validateData() const

   693 {

   694     NM_FUNCTION;

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

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

   697         

   698         bool validated = false;

   699         bool valid = false;        

   700         

   701         int key = i.key();

   702         QVariant val = i.value();

   703         

   704         ++i;

   705         

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

   707         if (validated) {

   708             if (!valid){

   709                 return valid;

   710             }

   711             continue;

   712         }

   713         

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

   715         if (validated) {

   716             if (!valid){

   717                 return valid;

   718             }

   719             continue;

   720         }

   721          

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

   723         if (validated) {

   724             if (!valid){

   725                 return valid;

   726             }

   727             continue;

   728         } 

   729          

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

   731         if (validated) {

   732             if (!valid){

   733                 return valid;

   734             }

   735             continue;

   736         }

   737      }

   738      return true;

   739 }

   740 

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

   742 {

   743     NM_FUNCTION;

   744     return mSettings->keys();

   745 }

   746 

   747 /*!

   748  \fn clearSettings 

   749  

   750  Resets data in this container. 

   751  */

   752 void NmApiMailboxSettingsDataPrivate::clearSettings()

   753 {

   754 	mSettings->clear();

   755 }

   756 

   757 }//end namespace