/**
ExecuteActionL
Sets the values for TImImap4GetMailInfo memeber variables and then store it
as an output parameter of the Test Action.
@internalTechnology
@pre None
@post None
@leave System wide errors
*/
void CMtfTestActionSetImap4FullDownloadLimits::ExecuteActionL()
{
TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionSetImap4FullDownloadLimits);
// Obtain Test Action input parameters
TInt paramTotalSizeLimit = ObtainValueParameterL<TInt>(TestCase(),
ActionParameters().Parameter(0),KMaxTInt);
TImap4GetMailOptions paramMailOptions = ObtainValueParameterL<TImap4GetMailOptions>
(TestCase(),ActionParameters().Parameter(1),
EGetImap4EmailHeaders);
TMsvId paramDestinationFolder = ObtainValueParameterL<TMsvId>
(TestCase(),ActionParameters().Parameter(2));
TMsvId paramServiceId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(3));
// Store the full donwload limits values
TImImap4GetMailInfo imap4GetMailInfo;
imap4GetMailInfo.iMaxEmailSize = paramTotalSizeLimit;
imap4GetMailInfo.iGetMailBodyParts = paramMailOptions;
imap4GetMailInfo.iDestinationFolder = paramDestinationFolder;
// Load the Imap account settings and save the download limits
CEmailAccounts* emailAccounts = CEmailAccounts::NewLC();
CImImap4Settings* imapSettings = new(ELeave) CImImap4Settings();
CleanupStack::PushL(imapSettings);
TImapAccount imapAccount;
emailAccounts->GetImapAccountL(paramServiceId, imapAccount);
emailAccounts->LoadImapSettingsL(imapAccount, *imapSettings);
imapSettings->SetMaxEmailSize( imap4GetMailInfo.iMaxEmailSize );
imapSettings->SetGetMailOptions( imap4GetMailInfo.iGetMailBodyParts );
emailAccounts->SaveImapSettingsL(imapAccount, *imapSettings);
CleanupStack::PopAndDestroy( 2, emailAccounts ); // imapSettings, emailSettings
// Store the full download limits as the ouput parameter of the Test Action
StoreParameterL<TImImap4GetMailInfo>(TestCase(),imap4GetMailInfo,
ActionParameters().Parameter(4));
TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionSetImap4FullDownloadLimits );
TestCase().ActionCompletedL(*this);
}
/**
Function : doTestStepL
Description : Fetches the srvice ID using the IMAP account name and sets
the full download limit fields of the setting object corresponding to it.
@return : TVerdict - Test step result
@leave : KMsvNullIndexEntryId If valid IMAP account name is not specified or
If valid remote folder name is not specified
*/
TVerdict CT_MsgSetImap4FullDownloadLimits::doTestStepL()
{
INFO_PRINTF1(KInfoTestStepName);
TPtrC imapAccountName;
/* Reads IMAP Account Name from ini file */
if(!GetStringFromConfig(ConfigSection(), KImapAccountName, imapAccountName))
{
ERR_PRINTF1(KAcntNameNtSpecified);
SetTestStepResult(EFail);
}
else
{
TPtrC destFolderName;
/* Reads the destination Folder Name */
if(!GetStringFromConfig(ConfigSection(), KFolderName, destFolderName))
{
ERR_PRINTF1(KDestFolderNtSpecified);
SetTestStepResult(EFail);
}
else
{
TInt maxEmailSize = KMaxTInt;
/* Reads the size of the Email to be set,where default is KMaxTInt */
GetIntFromConfig(ConfigSection(), KMaxEmailSize, maxEmailSize);
TPtrC mailOption;
/* Reads the mail option to be set from the ini file */
if(!GetStringFromConfig(ConfigSection(), KImapMailOption, mailOption))
{
ERR_PRINTF1(KGetMailOptNtSpecified);
SetTestStepResult(EFail);
}
else
{
TMsvId destFolderId = -1;
/* Retrieves the IMAP service Id based on the IMAP account name*/
TMsvId imapServiceId = CT_MsgUtilsCentralRepository::GetImapServiceIdL((TDes&) imapAccountName);
if(imapServiceId == KMsvNullIndexEntryId)
{
ERR_PRINTF2(KAcntNtExist, &imapAccountName);
SetTestStepResult(EFail);
}
else
{
/*
* Retrieves the mail options and the remote destination folder Id
* based on the IMAP account name and the remote folder name given
*/
TImap4GetMailOptions imapMailOption = CT_MsgUtilsEnumConverter::ConvertDesToTImap4GetMailOptions(mailOption);
destFolderId = CT_MsgUtils::GetRemoteFolderIdByNameL(iSharedDataIMAP.iSession,
imapAccountName,destFolderName);
if(destFolderId == KMsvNullIndexEntryId)
{
ERR_PRINTF1(_L("Invalid remote folder name specified"));
SetTestStepResult(EFail);
}
else
{
INFO_PRINTF2(KFolderId,destFolderId);
/* Stores the fulll donwload limit values */
TImImap4GetMailInfo imap4GetMailInfo;
imap4GetMailInfo.iMaxEmailSize = maxEmailSize;
imap4GetMailInfo.iGetMailBodyParts = imapMailOption;
imap4GetMailInfo.iDestinationFolder = destFolderId;
/* Loads the Imap account settings and save the download limits */
CEmailAccounts* emailAccounts = CEmailAccounts::NewLC();
CImImap4Settings* imapSettings = new(ELeave) CImImap4Settings();
CleanupStack::PushL(imapSettings);
TImapAccount imapAccount;
emailAccounts->GetImapAccountL(imapServiceId, imapAccount);
emailAccounts->LoadImapSettingsL(imapAccount, *imapSettings);
TBool deleteFlag;
if(GetBoolFromConfig(ConfigSection(),KDeleteFlag,deleteFlag))
{
imapSettings->SetDeleteEmailsWhenDisconnecting(deleteFlag);
}
TBool updateFlag;
if(GetBoolFromConfig(ConfigSection(),KUpdateFlag,updateFlag))
{
imapSettings->SetUpdatingSeenFlags(updateFlag);
}
TInt fetchSizeLimit = 20480;
if(GetIntFromConfig(ConfigSection(),KFetchSizeLimit,fetchSizeLimit))
{
imapSettings->SetFetchSizeL(fetchSizeLimit);
}
TInt inboxSyncLimit;
if(GetIntFromConfig(ConfigSection(),KInboxSyncLimit,inboxSyncLimit))
{
imapSettings->SetInboxSynchronisationLimit(inboxSyncLimit);
}
TInt mailboxSyncLimit;
if(GetIntFromConfig(ConfigSection(),KMailboxSyncLimit,mailboxSyncLimit))
{
imapSettings->SetMailboxSynchronisationLimit(mailboxSyncLimit);
}
TPtrC searchString;
if(GetStringFromConfig(ConfigSection(),KSearchString,searchString))
{
HBufC8* string = HBufC8::NewLC(searchString.Length());
string->Des().Copy(searchString);
imapSettings->SetSearchStringL(string->Des());
CleanupStack::PopAndDestroy(string);
}
TPtrC folderSubTypeName;
if(GetStringFromConfig(ConfigSection(),KFolderSubType,folderSubTypeName))
{
TFolderSubscribeType folderSubType = CT_MsgUtilsEnumConverter::ConvertDesToTFolderSubscribeType
((TDesC&)folderSubTypeName);
imapSettings->SetSubscribe(folderSubType);
}
TPtrC folderSyncTypeName;
if(GetStringFromConfig(ConfigSection(),KFolderSyncType,folderSyncTypeName))
{
TFolderSyncType folderSyncType = CT_MsgUtilsEnumConverter::ConvertDesToTFolderSyncType
((TDesC&)folderSyncTypeName);
imapSettings->SetSynchronise(folderSyncType);
}
/* Sets the download limts in the settings object created */
imapSettings->SetMaxEmailSize( imap4GetMailInfo.iMaxEmailSize );
imapSettings->SetGetMailOptions( imap4GetMailInfo.iGetMailBodyParts );
/* Saves the settings */
emailAccounts->SaveImapSettingsL(imapAccount, *imapSettings);
CleanupStack::PopAndDestroy(2,emailAccounts);/* imapSettings, emailAccounts */
INFO_PRINTF2(KInfoCompletionStatus, &KSetImap4FullDownloadLimits);
}
}
}
}
}
return TestStepResult();
}
/**
ReadImapSettingsFromConfigurationFileL()
Modifies the IMAP related default setting and IAP objects.
@param aSettingsFile
Configuration/setting file path.
@param aImapSet
CImImap4Settings object.
@param aImapIapPref
CImIAPPreferences object.
*/
EXPORT_C void CT_MsgUtilsReadEmailSettingsFromConfigFile::ReadImapSettingsFromConfigurationFileL(
TDesC& aSettingsFile, CImImap4Settings& aImapSet, CImIAPPreferences& aImapIapPref,const TDesC& /* aPtrEmailAdd */)
{
// Parses the setting file
CT_MsgUtilsConfigFileParserUtility* scriptFileParser = CT_MsgUtilsConfigFileParserUtility::NewL(aSettingsFile);
CleanupStack::PushL(scriptFileParser);
TPtrC8 string8Ptr;
TPtrC stringPtr = KNone();
TInt intTmp;
if(scriptFileParser->GetFieldAsString(KCfgImapServerAddress, stringPtr) == KErrNone)
{
aImapSet.SetServerAddressL(stringPtr);
}
CT_MsgUtilsConfigFileMachineName* machineNameFile = CT_MsgUtilsConfigFileMachineName::NewLC(stringPtr);
TPtrC8 machineName(machineNameFile->MachineName());
if(scriptFileParser->GetFieldAsString8(KCfgImapLoginName, string8Ptr) == KErrNone)
{
aImapSet.SetLoginNameL(string8Ptr);
}
else
{
aImapSet.SetLoginNameL(machineName);
}
if(scriptFileParser->GetFieldAsString8(KCfgImapPassword, string8Ptr) == KErrNone)
{
aImapSet.SetPasswordL(string8Ptr);
}
else
{
aImapSet.SetPasswordL(machineName);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapPort, intTmp) == KErrNone)
{
aImapSet.SetPort(intTmp);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapSecureSockets, intTmp) == KErrNone)
{
aImapSet.SetSecureSockets( (TBool) intTmp );
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapSSLWrapper, intTmp ) == KErrNone)
{
aImapSet.SetSSLWrapper( (TBool) intTmp );
}
if(scriptFileParser->GetFieldAsString8(KCfgImapFolderPath, string8Ptr) == KErrNone)
{
aImapSet.SetFolderPathL(string8Ptr);
}
if(scriptFileParser->GetFieldAsString8(KCfgImapPathSeperator, string8Ptr) == KErrNone)
{
if ( string8Ptr.Length() == 1 )
{
aImapSet.SetPathSeparator( string8Ptr[0] );
}
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapMaxEmailSize, intTmp) == KErrNone)
{
aImapSet.SetMaxEmailSize(intTmp);
}
if(scriptFileParser->GetFieldAsString(KCfgImapGetMailOptions, stringPtr) == KErrNone)
{
TImap4GetMailOptions setGetMailOptions = CT_MsgUtilsEnumConverter::ConvertDesToTImap4GetMailOptions(stringPtr);
aImapSet.SetGetMailOptions(setGetMailOptions);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapInboxSynchronisationLimit, intTmp) == KErrNone)
{
aImapSet.SetInboxSynchronisationLimit(intTmp);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapMailboxSynchronisationLimit, intTmp) == KErrNone)
{
aImapSet.SetMailboxSynchronisationLimit(intTmp);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapAutoSendOnConnect, intTmp) == KErrNone)
{
aImapSet.SetAutoSendOnConnect((TBool) intTmp);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapDeleteEmailsWhenDisconnecting, intTmp) == KErrNone)
{
aImapSet.SetDeleteEmailsWhenDisconnecting((TBool) intTmp);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapAcknowledgeReceipts, intTmp) == KErrNone)
{
aImapSet.SetAcknowledgeReceipts((TBool) intTmp);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapDisconnectedUserMode, intTmp) == KErrNone)
{
aImapSet.SetDisconnectedUserMode((TBool) intTmp);
}
if(scriptFileParser->GetFieldAsString(KCfgImapSynchronise, stringPtr) == KErrNone)
{
TFolderSyncType setFolderSyncType = CT_MsgUtilsEnumConverter::ConvertDesToTFolderSyncType(stringPtr);
aImapSet.SetSynchronise(setFolderSyncType);
}
if(scriptFileParser->GetFieldAsString(KCfgImapSubscribe, stringPtr) == KErrNone)
{
TFolderSubscribeType setFolderSubscribeType = CT_MsgUtilsEnumConverter::ConvertDesToTFolderSubscribeType(stringPtr);
aImapSet.SetSubscribe(setFolderSubscribeType);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapUpdatingSeenFlags, intTmp) == KErrNone)
{
aImapSet.SetUpdatingSeenFlags((TBool) intTmp);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapSyncRate, intTmp) == KErrNone)
{
aImapSet.SetSyncRateL(intTmp);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapFetchSize, intTmp) == KErrNone)
{
aImapSet.SetFetchSizeL(intTmp);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapIdle, intTmp) == KErrNone)
{
aImapSet.SetImapIdle( (TBool) intTmp );
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapIdleTimeout, intTmp) == KErrNone)
{
aImapSet.SetImapIdleTimeoutL(intTmp);
}
if(scriptFileParser->GetFieldAsString(KCfgImapPartialMailOptions, stringPtr) == KErrNone)
{
TImImap4PartialMailOptions setImap4PartialMailOptions = CT_MsgUtilsEnumConverter::ConvertDesToTImImap4PartialMailOptions(stringPtr);
aImapSet.SetPartialMailOptionsL(setImap4PartialMailOptions);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapBodyTextSizeLimit, intTmp) == KErrNone)
{
aImapSet.SetBodyTextSizeLimitL(intTmp);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapAttachmentSizeLimit, intTmp) == KErrNone)
{
aImapSet.SetAttachmentSizeLimitL(intTmp);
}
if(scriptFileParser->GetFieldAsString(KCfgImapIapList, stringPtr) == KErrNone)
{
ReadImapIAPAndAddL(scriptFileParser, (TDesC&)KCfgImapIapList, aImapIapPref);
}
if(scriptFileParser->GetFieldAsInteger(KUseExpunge, intTmp) == KErrNone)
{
aImapSet.SetUseExpunge( (TBool) intTmp);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapSNAPId, intTmp) == KErrNone)
{
aImapIapPref.SetSNAPL(intTmp);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapBearerMobility, intTmp) == KErrNone)
{
aImapSet.SetBearerMobility((TBool) intTmp);
}
if(scriptFileParser->GetFieldAsInteger(KCfgImapDownloadRules, intTmp) == KErrNone)
{
aImapSet.SetUseSyncDownloadRules((TBool) intTmp);
}
CleanupStack::PopAndDestroy(2,scriptFileParser);
}