/* ============================================================================

 *  Name        :  popimapprofiletester.cpp

 *  Part of     :  ipsservices / ipsprofiletester 

 *  Description :: STIF test cases

 *  Version     : %version: 1 % << Don't touch! Updated by Synergy at check-out.

 *

 *  Copyright © 2010-2010 Nokia and/or its subsidiary(-ies).  All rights reserved.

 *  This material, including documentation and any related computer

 *  programs, is protected by copyright controlled by Nokia.  All

 *  rights are reserved.  Copying, including reproducing, storing,

 *  adapting or translating, any or all of this material requires the

 *  prior written consent of Nokia.  This material also contains

 *  confidential information which may not be disclosed to others

 *  without the prior written consent of Nokia.

 * ============================================================================

 */

// INCLUDE FILES

#include <StifTestInterface.h>

#include "popimapprofiletester.h"

#include <SettingServerClient.h>

/*

 * define flag in ctg file

 */

_LIT( KSetupWizAccountType,"AccountType" );

_LIT( KSetupWizAccountsConfigured,"AccountsConfigured" );

_LIT( KSetupWizMaxAccountsReached,"MaxAccountsReached" );

_LIT( KSetupWizEmailAddress,"EmailAddress" );

_LIT( KSetupWizUsername,"Username" );

_LIT( KSetupWizPassword,"Password" );

_LIT( KSetupWizMailboxName,"MailboxName" );

_LIT( KSetupWizIncomingServer,"IncomingServer" );

_LIT( KSetupWizIncomingPort,"IncomingPort" );

_LIT( KSetupWizOutgoingServer,"OutgoingServer" );

_LIT( KSetupWizOutgoingPort,"OutgoingPort" );

_LIT( KSetupWizIncomingSecurityAuth,"IncomingSecurityAuth" );

_LIT( KSetupWizIncomingSecurityProtocol,"IncomingSecurityProtocol" );

_LIT( KSetupWizOutgoingSecurityAuth,"OutgoingSecurityAuth" );

_LIT( KSetupWizOutgoingSecurityProtocol,"OutgoingSecurityProtocol" );

_LIT( KSetupWizOperatorSecurityAuth,"OperatorSecurityAuth" );

_LIT( KSetupWizOperatorSecurityProtocol,"OperatorSecurityProtocol" );

_LIT( KSetupWizOperatorPort,"OperatorPort" );

_LIT(KProfileTesterDLL,"popimapprofiletester.dll");

_LIT(KAccountType,"AccountType");

_LIT(KIMAPAccount,"imap");

_LIT(KPOPAccount,"pop");

_LIT(KInboxType,"inbox");

_LIT(KOutboxType,"outbox");

_LIT(KDraftsType,"drafts");

_LIT(KSentType,"sent");

// Logging path

_LIT( KpopimapprofiletesterLogPath, "\\logs\\testframework\\popimapprofiletester\\" );

// Log file

_LIT( KpopimapprofiletesterLogFile, "popimapprofiletester.txt" );

_LIT( KpopimapprofiletesterLogFileWithTitle, "popimapprofiletester_[%S].txt" );

/*

 * default value for settings

 */

_LIT( KWizAccountTypeDefault,"fsp" );

// ============================ MEMBER FUNCTIONS ===============================

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

// CPopImapProfileTester::CPopImapProfileTester

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CPopImapProfileTester::CPopImapProfileTester(CTestModuleIf& aTestModuleIf) :

    CScriptBase(aTestModuleIf), iTimeoutTimer(NULL), iMailClient(NULL),

            iIPSMailbox(NULL), iTimeout(EFalse), iEventParam1(NULL),

            iEventParam2(NULL), iEventSynchronousCall(EFalse), iErr(KErrNone),

            iWaitingState(EWaitingNothing), iPluginId(TFSMailMsgId()),

            iSearchOngoing(EFalse), iSearchMatches(NULL)

    {

    }

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

// CPopImapProfileTester::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPopImapProfileTester::ConstructL()

    {

    //Read logger settings to check whether test case name is to be

    //appended to log file name.

    RSettingServer settingServer;

    TInt ret = settingServer.Connect();

    if (ret != KErrNone)

        {

        User::Leave(ret);

        }

    // Struct to StifLogger settigs.

    TLoggerSettings loggerSettings;

    // Parse StifLogger defaults from STIF initialization file.

    ret = settingServer.GetLoggerSettings(loggerSettings);

    if (ret != KErrNone)

        {

        User::Leave(ret);

        }

    // Close Setting server session

    settingServer.Close();

    TFileName logFileName;

    if (loggerSettings.iAddTestCaseTitle)

        {

        TName title;

        TestModuleIf().GetTestCaseTitleL(title);

        logFileName.Format(KpopimapprofiletesterLogFileWithTitle, &title);

        }

    else

        {

        logFileName.Copy(KpopimapprofiletesterLogFile);

        }

    iLog = CStifLogger::NewL(KpopimapprofiletesterLogPath, logFileName,

            CStifLogger::ETxt, CStifLogger::EFile, EFalse);

    SendTestClassVersion();

    iWait = new (ELeave) CActiveSchedulerWait();

    iTimeoutTimer = CTimeoutTimer::NewL(*this);

    // create a mail client

    iMailClient = CFSMailClient::NewL();

    if (iMailClient)

        {

        iMailClient->AddObserverL(*this);

        iLog->Log(_L( "Mail Client was created" ));

        }

    else

        {

        iLog->Log(_L( "ERROR: Mail Client not created" ));

        }

    }

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

// CPopImapProfileTester::NewL

// Two-phased constructor.

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

//

CPopImapProfileTester* CPopImapProfileTester::NewL(CTestModuleIf& aTestModuleIf)

    {

    CPopImapProfileTester* self = new (ELeave) CPopImapProfileTester(

            aTestModuleIf);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CPopImapProfileTester::~CPopImapProfileTester()

    {

    // Delete resources allocated from test methods

    Delete();

    if (iMailClient)

        {

        if (NULL != iIPSMailbox)

            {

            iMailClient->UnsubscribeMailboxEvents(iIPSMailbox->GetId(), *this);

            delete iIPSMailbox;

            iIPSMailbox = NULL;

            }

        iMailClient->Close();

        }

    DELANDNULL(iTimeoutTimer);

    // Delete logger

    DELANDNULL(iLog);

    //Delete waiter

    if (NULL != iWait && iWait->IsStarted())

        {

        iWait->AsyncStop();

        }

    DELANDNULL(iWait);

    }

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

// CPopImapProfileTester::SendTestClassVersion

// Method used to send version of test class

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

//

void CPopImapProfileTester::SendTestClassVersion()

    {

    TVersion moduleVersion;

    moduleVersion.iMajor = TEST_CLASS_VERSION_MAJOR;

    moduleVersion.iMinor = TEST_CLASS_VERSION_MINOR;

    moduleVersion.iBuild = TEST_CLASS_VERSION_BUILD;

    TFileName moduleName;

    moduleName = KProfileTesterDLL;

    TBool newVersionOfMethod = ETrue;

    TestModuleIf().SendTestModuleVersion(moduleVersion, moduleName,

            newVersionOfMethod);

    }

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

// CPopImapProfileTester::DeleteTestMsgL

// Method used to delete msgs in a specific folder

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

//

TInt CPopImapProfileTester::DeleteTestMsgL(TDesC& aFolderName)

    {

    TInt err(KErrNone);

    TInt msgCount(0); //number of messages in folder

    // Step 01: to find a folder

    CFSMailFolder* folder = FindFolder(aFolderName);

    RArray<TFSMailMsgId> msgsToBeDeleted;

    CleanupClosePushL(msgsToBeDeleted);

    if (NULL != folder)

        {

        // Step 02: to list all test messages to be deleted from this folder

        RPointerArray<CFSMailMessage> messages;

        TInt gotMsgs = GetMessagesFromFolderL(messages, folder,

                EFSMsgDataSubject, EFSMailSortByDate, msgCount);

        // Step 03: to find to be deleted msgs 

        for (TInt i = 0; i < messages.Count(); i++)

            {

            //deleted msgs with STIF

            if (messages[i]->GetSubject().Find(_L("STIF" )) != KErrNotFound)

                {

                iLog->Log(_L("Found: %d. %S"), i + 1,

                        &messages[i]->GetSubject());

                msgsToBeDeleted.Append(messages[i]->GetMessageId());

                }

            }//end loop: 'for'

        if (msgsToBeDeleted.Count() > 0)

            {

            iLog->Log(_L("  -Deleting %d message(s)"), msgsToBeDeleted.Count());

            iMailClient->DeleteMessagesByUidL(iIPSMailbox->GetId(),

                    folder->GetFolderId(), msgsToBeDeleted);

            err = WaitForEvent(TFSEventMailDeleted, NULL, NULL, KOneMinuteTime);

            iIPSMailbox->RefreshNowL(*this);

            if (KErrNone == WaitForEvent(TFSEventMailboxOnline))

                {

                WaitForResponse(TFSProgress::EFSStatus_RequestComplete,

                        KHalfMinuteTime);

                }

            }//end if: 'count()>0'

        else

            {

            iLog->Log(_L("Not find messages(STIF) to delete"));

            err = KErrNotFound;

            }

        messages.ResetAndDestroy();

        }// end if 'inboxFolder'

    else

        {

        err = KErrNotFound;

        iLog->Log(_L(" %S is NOT found.(Error's ID:%d)"), &aFolderName, err);

        }

    CleanupStack::PopAndDestroy(&msgsToBeDeleted);

    return err;

    }

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

// CPopImapProfileTester::FindFoler

// Method used to find a folder with folder's name

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

CFSMailFolder* CPopImapProfileTester::FindFolder(const TDesC& aFolderName)

    {

    CFSMailFolder* folder(NULL);

    RPointerArray<CFSMailFolder>& allFolders = iIPSMailbox->ListFolders();

    TFSMailMsgId folderId = GetFolderIdFromName(aFolderName);

    for (TInt i = 0; i < allFolders.Count(); ++i)

        {

        if (allFolders[i]->GetFolderId() == folderId)

            {

            iLog->Log(_L("Found: %S folder"), &allFolders[i]->GetFolderName());

            folder = allFolders[i];

            break;

            }

        }

    return folder;

    }

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

// CPopImapProfileTester::GetMessagesFromFolderL

// Method used to get messages from specific folder

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

TInt CPopImapProfileTester::GetMessagesFromFolderL(

        RPointerArray<CFSMailMessage>& aMessages, CFSMailFolder* aFolder,

        TFSMailDetails aDet, TFSMailSortField aSort, TUint aCount)

    {

    TFSMailSortCriteria sortCriteria;

    sortCriteria.iField = aSort;

    sortCriteria.iOrder = EFSMailDescending; // default sort order: Descending

    RArray<TFSMailSortCriteria> sorting;

    CleanupClosePushL(sorting);

    // append primary criteria

    sorting.Append(sortCriteria);

    MFSMailIterator* iterator = aFolder->ListMessagesL(aDet, sorting);

    CleanupStack::PopAndDestroy(&sorting);

    CleanupDeletePushL(iterator);

    TInt messageCount = aFolder->GetMessageCount();

    iLog->Log(_L("  %d message(s) in '%S'"), messageCount,

            &aFolder->GetFolderName());

    if (aCount > 0)

        {

        if (messageCount < aCount)

            {

            aCount = messageCount;

            }

        }

    else

        {

        aCount = messageCount;

        }

    iterator->NextL(TFSMailMsgId(), aCount, aMessages);

    CleanupStack::PopAndDestroy(iterator);

    return aCount;

    }

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

// CPopImapProfileTester::EventL

// from MFSMailEventObserver

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

//

void CPopImapProfileTester::EventL(TFSMailEvent aEvent,

        TFSMailMsgId /*aMailbox*/, TAny* aParam1, TAny* aParam2, TAny* aParam3)

    {

    LogEvent(_L("Receive Event->"), aEvent, aParam1, aParam2, aParam3);

    if ((aEvent == iCurrWaitedEvent) && (iWait->IsStarted()) && (iWaitingState

            == EWaitingEvent) && ParseEventParams(aParam1, aParam2))

        OpComplete();

    }

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

// CPopImapProfileTester::RequestResponseL

// from MFSMailRequestObserver

// It proivdes progress/status information of requested functions

// i.e. DeleteMailBoxByUidL, RefreshNowL

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

//

void CPopImapProfileTester::RequestResponseL(TFSProgress aEvent,

        TInt aRequestId)

    {

    LogTFSProgress(_L("Receive Response->"), aEvent.iProgressStatus, aRequestId);

    if ((aEvent.iProgressStatus == iCurrWaitedResponse) && (iWaitingState

            == EWaitingResponse) && (iWait->IsStarted()))

        OpComplete();

    }

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

// CPopImapProfileTester::MatchFoundL

// from MFSMailBoxSearchObserver

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

//

void CPopImapProfileTester::MatchFoundL(CFSMailMessage* aMatchMessage)

    {

    TBuf<20> tempFolderName;

    GetFolderNameFromId(aMatchMessage->GetFolderId(), tempFolderName);

    TPtrC folderName = tempFolderName.Mid(0);

    iLog->Log(_L("  MatchFound %S in %S"), &aMatchMessage->GetSubject(),

            &folderName);

    if (iSearchOngoing)

        {

        iSearchMatches++;

        }

    delete aMatchMessage;

    }

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

// CPopImapProfileTester::SearchCompletedL

// from MFSMailBoxSearchObserver

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

//

void CPopImapProfileTester::SearchCompletedL()

    {

    if (iWait->IsStarted())

        {

        OpComplete();

        iLog->Log(_L(" SearchCompleted"));

        }

    else

        {

        iLog->Log(_L("Error: SearchCompleted callback"));

        }

    }

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

// CPopImapProfileTester::ClientRequiredSearchPriority

// from MFSMailBoxSearchObserver

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

//

void CPopImapProfileTester::ClientRequiredSearchPriority(TInt* /*apRequiredSearchPriority*/)

    {

    iLog->Log(_L("  ClientRequiredSearchPriority"));

    }

void CPopImapProfileTester::TimeoutNotify()

    {

    iTimeout = ETrue;

    OpComplete();

    }

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

// CPopImapProfileTester::SendMsgL

// Method is a actual sending message function.

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

//

TInt CPopImapProfileTester::SendMsgL(CFSMailMessage& aMsg,

        const TDesC &aSubject, TFSMailMsgId& aGotMsgId)

    {

    TInt err(KErrNone);

    TInt msgCount(0);

    //to call actual function to send message

    TRAP( err, iIPSMailbox->SendMessageL( aMsg ) );

    //second asynchronous when moving msg from Outbox to Sent Items ( this actually tells msg was sent )

    if (KErrNone == err)

        {

        //Wait for email to be sent

        TFSMailMsgId folderId = iIPSMailbox->GetStandardFolderId(EFSSentFolder);

        iIPSMailbox->RefreshNowL();

        err = WaitForEvent(TFSEventMailMoved, NULL, &folderId);

        iIPSMailbox->GoOfflineL();

        WaitForEvent(TFSEventMailboxOffline);

        iIPSMailbox->RefreshNowL(*this);

        WaitForResponse(TFSProgress::EFSStatus_RequestComplete);

        if (KErrNone == err)

            {

            // Step04: To check 'Inbox' folder to sure message sent

            TFSMailMsgId folderId = iIPSMailbox->GetStandardFolderId(EFSInbox);

            CFSMailFolder* folder = iMailClient->GetFolderByUidL(

                    iIPSMailbox->GetId(), folderId);

            CleanupStack::PushL(folder);

            if (NULL != folder)

                {

                RPointerArray<CFSMailMessage> messages;

                TInt gotMsgs = GetMessagesFromFolderL(messages, folder,

                        EFSMsgDataSubject, EFSMailSortByDate, msgCount);

                if (gotMsgs > 0)

                    {

                    iLog->Log(_L("  Listing first %d emails:"), gotMsgs);

                    for (TInt i = 0; i < messages.Count(); i++)

                        {

                        iLog->Log(_L("Found: %S"), &messages[i]->GetSubject());

                        if (messages[i]->GetSubject().Compare(aSubject) == 0)

                            {

                            iLog->Log(

                                    _L("Success:Email '%S' sent to own mail address"),

                                    &messages[i]->GetSubject());

                            aGotMsgId.SetPluginId(

                                    messages[i]->GetMessageId().PluginId());

                            aGotMsgId.SetId(messages[i]->GetMessageId().Id());

                            err = KErrNone;

                            break;

                            }

                        else

                            {

                            err = KErrNotFound;

                            }

                        }//end loop: 'for'

                    }//end if 'msgCount'

                else

                    {

                    err = KErrNotFound;

                    iLog->Log(_L("No message in %S folder"),

                            &folder->GetFolderName());

                    }

                messages.ResetAndDestroy();

                }//end if 'folder'

            else

                {

                err = KErrNotFound;

                iLog->Log(_L("Folder is NOT found.(Error's ID:%d)"), err);

                }

            CleanupStack::PopAndDestroy(folder);

            }//end if: checking whether 'msg' sent or not

        }//end if 'KErrNone == err'

    return err;

    }

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

// CPopImapProfileTester::DoSearch

// Method used to launches SearchL and waits for completion

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

//

TInt CPopImapProfileTester::DoSearch(

        const RPointerArray<TDesC>& aSearchStrings,

        const TFSMailSortCriteria& aSortCriteria, TInt aTimeout)

    {

    TInt err(KErrNone);

    if (iSearchOngoing)

        {

        iLog->Log(_L("  Error: Search in progress"));

        err = KErrInUse;

        }

    else

        {

        iIPSMailbox->ClearSearchResultCache();

        iSearchMatches = EFalse;

        TRAP( err, iIPSMailbox->SearchL( aSearchStrings, aSortCriteria, *this ) );

        if (KErrNone != err)

            {

            iLog->Log(_L("  Error: SearchL leaves with %d"), err);

            }

        else

            {

            iLog->Log(_L("  Searching for '%S':"), aSearchStrings[0]);

            iSearchOngoing = ETrue;

            iTimeoutTimer->Start(aTimeout * 1000000);

            iWait->Start();

            if (iTimeout)

                {

                iLog->Log(_L("  Error: Search not completed within %d sec"),

                        aTimeout);

                err = KErrTimedOut;

                }

            else