/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   ?Description

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <StifParser.h>

#include <StifTestInterface.h>

#include <liwservicehandler.h>

#include <liwcommon.h>

#include <VPbkEng.rsg>

#include <e32def.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactStoreList.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkContactLink.h>

#include <CVPbkContactLinkArray.h>

#include <MVPbkContactGroup.h>

#include <CVPbkContactManager.h>

#include <MVPbkContactStoreList.h>

#include <MVPbkContactStore.h>

#include <TVPbkContactStoreUriPtr.h>

#include <CVPbkFieldTypeRefsList.h>

#include <MVPbkContactFieldTextData.h>

#include<f32file.h>

#include "tcomplugin.h"

_LIT(LogFileName , "C:\\Notifications.txt") ;

_LIT(KError,"Error code is");

_LIT(KSuccess,"Successful");

_LIT(KNewLine,"\n");

_LIT(KServiceOpen,"Service handle created");

_LIT(KServiceClose,"Service handle deleted");

_LIT(KPhoneNumber,"9886431364");

 _LIT(KGroup1,"Test1");

_LIT8( KIDataSource,"IDataSource" );

_LIT8( KExitCode, "ErrorCode" );

_LIT8( KService, "Service.Contact" );

//commands that can be performed on the contacts database.

_LIT8( KCmdImport, "Import" );

_LIT8( KCmdExport, "Export" );

_LIT8( KCmdGetList, "GetList");

_LIT8( KCmdAdd, "Add" );

_LIT8( KCmdDelete, "Delete" );

_LIT8( KCmdOrganiseGroups, "Organise" );

_LIT8( KCancel, "Cancel" );

// Constant for the appending Error code

_LIT8( KErrorCode, "ErrorCode" );

// Constant for the appending TransactionID

_LIT8( KTransactionID, "TransactionID" );

//Constant for appending Iterator

_LIT8( KReturnValue, "ReturnValue");

_LIT8(KSourceFileNameParam, "SourceFile");

_LIT8(KDestFileNameParam, "DestinationFile");

_LIT8(KGroupId,"id");

_LIT8(KFieldLabel, "Label");

_LIT8(KFieldValue, "Value");

_LIT8(KFieldNext, "Next");

_LIT8(KGroupLabel, "GroupLabel");

_LIT8(KContents, "Contents");

_LIT8(KContactId, "id");

_LIT8(KList, "IdList"); 

_LIT8(KContact, "Contact");

_LIT8(KGroup, "Group");

_LIT8(KDatabase, "Database");

_LIT8(KDBUri, "DBUri");

_LIT8(KSearchVal, "SearchVal");

_LIT8(KType, "Type");

_LIT8(KFilter, "Filter");

_LIT8(KSort, "Sort");

_LIT8(KOrder, "Order");

_LIT8(KData, "Data");

_LIT8(KOperationType, "OperationType");

_LIT(KAssociate, "Associate"); 

_LIT(KDissociate, "Disassociate");

_LIT(KAscending, "Ascending"); 

_LIT(KDescending, "Descending"); 

//Field Keys

_LIT8(KSync, "Sync"); 

_LIT8(KLastName, "LastName"); 

_LIT8(KLastNameReading, "LastNameReading"); 

_LIT8(KFirstName, "FirstName"); 

_LIT8(KFirstNameReading, "FirstNameReading"); 

_LIT8(KPrefix, "Prefix"); 

_LIT8(KSuffix, "Suffix"); 

_LIT8(KSecondName, "SecondName"); 

_LIT8(KLandPhoneHome, "LandPhoneHome"); 

_LIT8(KMobilePhoneHome, "MobilePhoneHome"); 

_LIT8(KVideoNumberHome, "VideoNumberHome"); 

_LIT8(KFaxNumberHome, "FaxNumberHome"); 

_LIT8(KVoipHome, "VoipHome"); 

_LIT8(KEmailHome, "EmailHome"); 

_LIT8(KURLHome, "URLHome"); 

_LIT8(KAddrLabelHome, "AddrLabelHome"); 

_LIT8(KAddrPOHome, "AddrPOHome"); 

_LIT8(KAddrEXTHome, "AddrEXTHome"); 

_LIT8(KAddrStreetHome, "AddrStreetHome"); 

_LIT8(KAddrLocalHome, "AddrLocalHome"); 

_LIT8(KAddrRegionHome, "AddrRegionHome"); 

_LIT8(KAddrPostCodeHome, "AddrPostCodeHome"); 

_LIT8(KAddrCountryHome, "AddrCountryHome"); 

_LIT8(KJobTitle, "JobTitle"); 

_LIT8(KCompanyName,"CompanyName"); 

_LIT8(KLandPhoneWork, "LandPhoneWork"); 

_LIT8(KMobilePhoneWork, "MobilePhoneWork"); 

_LIT8(KVideoNumberWork, "VideoNumberWork"); 

_LIT8(KFaxNumberWork, "FaxNumberWork"); 

_LIT8(KVoipWork, "VoipWork"); 

_LIT8(KEmailWork, "EmailWork"); 

_LIT8(KURLWork, "URLWork"); 

_LIT8(KAddrLabelWork, "AddrLabelWork"); 

_LIT8(KAddrPOWork, "AddrPOWork"); 

_LIT8(KAddrEXTWork, "AddrEXTWork"); 

_LIT8(KAddrStreetWork, "AddrStreetWork"); 

_LIT8(KAddrLocalWork, "AddrLocalWork"); 

_LIT8(KAddrRegionWork, "AddrRegionWork"); 

_LIT8(KAddrPostCodeWork, "AddrPostCodeWork"); 

_LIT8(KAddrCountryWork, "AddrCountryWork"); 

_LIT8(KLandPhoneGen, "LandPhoneGen"); 

_LIT8(KMobilePhoneGen, "MobilePhoneGen"); 

_LIT8(KVideoNumberGen, "VideoNumberGen"); 

_LIT8(KFaxNumberGen, "FaxNumberGen"); 

_LIT8(KVOIPGen, "VOIPGen"); 

_LIT8(KPOC, "POC"); 

_LIT8(KSWIS, "SWIS"); 

_LIT8(KSIP, "SIP"); 

_LIT8(KEmailGen, "EmailGen"); 

_LIT8(KURLGen, "URLGen"); 

_LIT8(KAddrLabelGen, "AddrLabelGen"); 

_LIT8(KAddrPOGen, "AddrPOGen"); 

_LIT8(KAddrExtGen, "AddrExtGen"); 

_LIT8(KAddrStreetGen, "AddrStreetGen"); 

_LIT8(KAddrLocalGen, "AddrLocalGen"); 

_LIT8(KAddrRegionGen, "AddrRegionGen"); 

_LIT8(KAddrPostCodeGen, "AddrPostCodeGen"); 

_LIT8(KAddrCountryGen, "AddrCountryGen"); 

_LIT8(KPageNumber, "PageNumber"); 

_LIT8(KDTMFString, "DTMFString"); 

_LIT8(KWVAddress, "WVAddress"); 

_LIT8(KDate, "Date"); 

_LIT8(KNote, "Note"); 

_LIT8(KThumbNailPic, "ThumbNailPic"); 

_LIT8(KRingtone, "Ringtone"); 

_LIT8(KCallerObjImg, "CallerObjImg"); 

_LIT8(KCallerObjText, "CallerObjText"); 

_LIT8(KMiddleName, "MiddleName"); 

_LIT8(KDepartment, "Department"); 

_LIT8(KAsstName, "AsstName"); 

_LIT8(KSpouse, "Spouse"); 

_LIT8(KChildren, "Children"); 

_LIT8(KAsstPhone, "AsstPhone"); 

_LIT8(KCarPhone, "CarPhone"); 

_LIT8(KAnniversary, "Anniversary"); 

_LIT8(KSyncClass, "SyncClass"); 

_LIT8(KLOCPrivacy, "LOCPrivacy"); 

_LIT8(KGenLabel, "GenLabel");

_LIT8(KXSPID, "IMPP");

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

// CTestProvider :: Delete()

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

void CTestProvider::Delete() 

    {

    iIface->Close();

    iCriteriaArray.Close();

    delete iServiceHandler;    

    delete iInparams;

    delete iOutparams;

    delete iCriteria;

    delete inList;

    delete outList;

    iIdArrayList.ResetAndDestroy();

    delete iCntID;

    }

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

// CTestProvider::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt CTestProvider::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function.          

        ENTRY("GetContactALL" , CTestProvider :: GetContactALL),

        ENTRY("GetContactSearch" , CTestProvider :: GetContactSearch),

        ENTRY("GetGroup" , CTestProvider :: GetGroup),

        ENTRY("GetDatabase" , CTestProvider :: GetDatabase),

        ENTRY("AddContact" , CTestProvider :: AddContact),

        ENTRY("DeleteContact" , CTestProvider :: DeleteContact),

        ENTRY("AddGroup" , CTestProvider :: AddGroup),

       	ENTRY("OrganiseAdd" , CTestProvider :: OrganiseAdd),

       	ENTRY("OrganiseDelete" , CTestProvider:: OrganiseDelete),

       	ENTRY("Export" , CTestProvider:: ExportL),

       	ENTRY("Import" , CTestProvider:: ImportL),

       	ENTRY("ModifyContact" , CTestProvider:: ModifyContact),

       	ENTRY("ModifyGroup" , CTestProvider:: ModifyGroup),

       	ENTRY("GetContactALLPosBased" , CTestProvider:: GetContactALLPosBased),

       	ENTRY("GetContactSearchPosBased" , CTestProvider:: GetContactSearchPosBased),

       	ENTRY("GetGroupPosBased" , CTestProvider:: GetGroupPosBased),

       	ENTRY("GetDatabasePosBased" , CTestProvider:: GetDatabasePosBased),

       	ENTRY("AddContactPosBased" , CTestProvider:: AddContactPosBased),

       	ENTRY("AddGroupPosBased" , CTestProvider:: AddGroupPosBased),

       	ENTRY("DeleteContactPosBased" , CTestProvider:: DeleteContactPosBased),

       	ENTRY("OrganiseAddPosBased" , CTestProvider :: OrganiseAddPosBased ),

       	ENTRY("OrganiseDeletePosbased" , CTestProvider :: OrganiseDeletePosbased),

       	ENTRY("ModifyContactPosBased" , CTestProvider :: ModifyContactPosBased),

       	ENTRY("ModifyGroupPosBased" , CTestProvider :: ModifyGroupPosBased),

       	ENTRY("ExportPosBased" , CTestProvider :: ExportPosBased),

       	ENTRY("ImportPosBased" , CTestProvider :: ImportPosBased),        	       	

       	ENTRY("CancelGetList" , CTestProvider :: CancelGetList),   

       	ENTRY("CancelAddContact" , CTestProvider :: CancelAddContact),   

       	ENTRY("CancelOrganiseAdd" , CTestProvider :: CancelOrganiseAdd),

       	ENTRY("CancelDeleteContact" , CTestProvider :: CancelDeleteContact),      	

       	ENTRY("CancelExport" , CTestProvider :: CancelExportL),   

       	ENTRY("CancelImport" , CTestProvider :: CancelImportL),

       	ENTRY("AddContactASyncTest" , CTestProvider :: AddContactASyncTestL),

       	ENTRY("AddGroupASyncTest" , CTestProvider :: AddGroupASyncTestL),

       	ENTRY("GetListNewFieldsTest" , CTestProvider :: GetListNewFieldsTestL)

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

TInt CTestProvider :: HandleNotifyL(TInt aCmdId,

                    	            TInt aEventId,

                    	            CLiwGenericParamList& aEventParamList,

                    	            const CLiwGenericParamList& aInParamList)

    {

    if (iCancelled != 1)

    	{

    	CActiveScheduler::Stop();

    	iCancelled  = 0;	

    	}

    TInt pos = 0;   

    const TLiwGenericParam* param;

    param = aEventParamList.FindFirst( pos, KExitCode );    

    TLiwVariant err = param->Value();

    TInt code = err.AsTInt32();

    if(iCase == EModifyContactComplete)

        {

        //call the get list once again to check whether the contact is modified

        iCase = EModifyContactVerify;

        //this time call the getlist with the contact id to get only the modified contact

        GetContactALL(*stiff);    

        }

    else if(iCase == EGetAllContacts ||iCase == EDeleteContact 

            || iCase == EOrganizeAddcntid || iCase == EVerifyImport 

            || iCase == EModifyContact || iCase == EModifyContactVerify)

        {   

        if (aEventId == KLiwEventCanceled)

        	{

        	iResult = KErrNone;	

        	}

        else

        	{

        	pos = 0;

        TBool tResult = EFalse;

        TBool bResult = EFalse;

        TBool findResult = EFalse;

        TBuf<255> firstName;

        TLiwVariant cntId;

        TLiwVariant mapfield;

        TLiwVariant firstname;

        TLiwVariant entry;

        const CLiwMap* map = NULL;

        const CLiwMap* mapField = NULL;

        param = aEventParamList.FindFirst(pos, KReturnValue);

        TLiwVariant iterator = param->Value();

        CLiwIterable* iter = iterator.AsIterable();            

        while(iter->NextL(entry))

            {                                           

            map = entry.AsMap();

            TInt count1 = map->Count();                       

            map->FindL(KContactId, cntId);                                 

            TPtrC ptr = cntId.AsDes();                

            if(iCase == EDeleteContact)

                {

                *iCntID = ptr;

                break;    

                }

            if(iCase == EOrganizeAddcntid)

                {

                TDesC* ptrtoCntId;

                TInt count = iIdArrayList.Count();

                for(TInt i = 0; i<count ; i++)

                    {

                    ptrtoCntId = iIdArrayList[i];

                    if( *ptrtoCntId == ptr )

                        {

                        findResult = ETrue; 

                        break;   

                        }

                    }

                if(findResult)

                    {

                    findResult = EFalse;

                    continue;    

                    }

                else

                    {

                    *iCntID = ptr; 

                    break;    

                    }                    

                }                        

            if(map->FindL(KFirstName,mapfield))

            mapField = mapfield.AsMap();

            TInt count = mapField->Count();            

            mapField->FindL(KFieldValue,firstname);

            firstName = firstname.AsDes();

            if(iCase == EModifyContact )

                {

                if((firstName.CompareF(_L("Arnold")) == 0))

                    {

                    *iCntID=ptr; 

                    break;                     

                    }

                else

                    {

                    continue;    

                    }    

                }

            if(iCase == EModifyContactVerify )

                {

                if((firstName.CompareF(_L("Modified Arnold")) == 0))

                    {

                    iResult = KErrNone; 

                    break;                     

                    }

                else

                    {

                    continue;    

                    }    

                }    

            if(iCase == EVerifyImport )

                {

                if((firstName.CompareF(_L("Monica Bellucci")) == 0) || (firstName.CompareF(_L("Kate Winslet")) == 0))

                    {

                    iResult = KErrNone;

                    break;

                    }

                else

                    {

                    continue;    

                    }        

                }

            if(firstName.CompareF(_L("Johnny")) == 0)       

                {

                tResult = ETrue;    

                }

            if(firstName.CompareF(_L("Arnold")) == 0)       

                {

                bResult = ETrue;    

                }                                                       

            }

            if(tResult && bResult)

                {

                iResult = KErrNone;    

                }

            if( iCase == EDeleteContact )

                {

                iCase = EDeleteVerify;

                }

            iterator.Reset();              

        	}

        }

    else if(iCase == EGetContactSearch)

        {    

        pos = 0;

        TBuf<255> firstName;

        TLiwVariant cntId;

        TLiwVariant mapfield;

        TLiwVariant firstname;

        TLiwVariant entry;

        const CLiwMap* map = NULL;

        const CLiwMap* mapField = NULL;

        param = aEventParamList.FindFirst(pos, KReturnValue);

        TLiwVariant iterator = param->Value();

        CLiwIterable* iter = iterator.AsIterable();

        while(1)

            {

            if(iter->NextL(entry))

                {

                map = entry.AsMap();

                TInt count1 = map->Count();       

                map->FindL(KContactId, cntId);                   

                TPtrC8 ptr = cntId.AsData();                 

                if(map->FindL(KFirstName,mapfield))

                mapField = mapfield.AsMap();

                TInt count = mapField->Count();

                firstname.Reset();

                mapField->FindL(KFieldValue,firstname);

                firstName = firstname.AsDes();

                if(firstName.CompareF(_L("Johnny")) == 0)       

                    {

                    iResult = KErrNone;    

                    }    

                }

            else

                {

                break;                    

                }

            }

        }

    else if(iCase == EDeleteVerify)

        {

        if (aEventId == KLiwEventCanceled)

        	{

        	iResult = KErrNone;	

        	}

        else if(aEventId == KLiwEventCompleted && code == KErrNone)//KLiwEventCompleted

            {

            iResult = KErrNone;             

            }

        else

            {

            iResult = code;    

            }  

        }

   	 else if(iCase == EGetGroup || iCase ==  EVerifyGroupAdd || iCase ==  EVerifyOrganizeDelete)

        {

        pos = 0;

        TBuf<255> groupName;

        TLiwVariant cntId;

        TLiwVariant groupLabel;

        TLiwVariant contents;

        TLiwVariant entry;

        const CLiwMap* map = NULL; 

        const CLiwList* list =NULL;       

        param = aEventParamList.FindFirst(pos, KReturnValue);

        TLiwVariant iterator = param->Value();

        CLiwIterable* iter = iterator.AsIterable();   

        while(iter->NextL(entry))         

            {            

            map = entry.AsMap();

            TInt count1 = map->Count(); 

            map->FindL(KGroupId, cntId);                   

            TPtrC ptr = cntId.AsDes();            

            if(map->FindL(KGroupLabel,groupLabel))

                {

                groupName = groupLabel.AsDes();

                iGrpID.Set(ptr);                     

                }

            if(groupName == _L("Test"))

                {

                if(map->FindL(KContents,contents))

                    {

                    iResult = KErrNone;

                    list = contents.AsList();

                    TInt count = list->Count();

                    for(TInt i=0; i<count ; i++)

        				{

        				TLiwVariant cntId;

        				list->AtL(i, cntId) ;

        				TPtrC cntid = cntId.AsDes() ;

        				HBufC* cnt = HBufC::NewL(cntid.Length());

        				*cnt = cntid;

        				iIdArrayList.AppendL(cnt);

        				}