/*

* 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 <SAPI_TEST\testprg.h>

#include <badesca.h>

#include "tcalendarexporttest.h"

#include "teststartconsolealarmserver2.h"

TDesC& GetEntry(MLiwInterface* interface, CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, TPtrC globaluid, const TDesC& calname);

_LIT(KCalNameExportTestDirect, "ExportTothisatProvider");

TInt AddProvAppointmentDailyRepeat(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);

class CCalCallback : public MLiwNotifyCallback

	{

	public:

		static CCalCallback* NewL(CActiveSchedulerWait* aWaitSchedular, TInt& aResult );

		virtual ~CCalCallback(){}

		TInt HandleNotifyL(TInt aCmdId,

	            TInt aEventId,

	            CLiwGenericParamList& aEventParamList,

	            const CLiwGenericParamList& aInParamList);

		TInt			iEntryAdded;

	private:

 		CCalCallback(CActiveSchedulerWait* aWaitSchedular, TInt& aResult ):iWaitSchedular(aWaitSchedular), iResult(aResult){ }

		CActiveSchedulerWait* 	iWaitSchedular;

		TInt& 			iResult;

	};

class CTestAsync : public CActive

{

public:

	static CTestAsync* NewL();

	~CTestAsync();

	void Start(TInt flag, TInt option, TBool aICalFormat = EFalse, TBool aAsync = EFalse, TBool aPosBased = EFalse, TBool aInvalidFormat = EFalse);

	void CancelNotification();

	TInt Result();

private:

	void ConstructL();

	CTestAsync();

	virtual void DoCancel();

	virtual void RunL();

	void TestFunc();

private:	

	CLiwServiceHandler* 	iServiceHandler;

	CActiveSchedulerWait* 	iWaitSchedular;

	TInt 					iResult;

	TInt 					iEntryAdded;	

	CCalCallback*			iCallback;

	MLiwInterface* 			interface;

	TInt32 					iTransactionId;

	TBool					iICalFormat;

	TBool					iAsync;		

	TInt 					iOption;

	TInt                    iFunc; 

	TBool                   iPosBased;

	TBool                   iInvalidFormat;

};

_LIT8(KTestInterface, 	"IDataSource");

_LIT8(KTestContent,		"Service.Calendar");

_LIT8(KCmd,				"RequestNotification");

_LIT(KEntryTypeMeeting,	"Meeting");

_LIT(KCalTestImportSync1, "C:CalendarExportFile1");

_LIT(KCalTestImportSync2, "C:CalendarExportFile2");

TInt RemoveProvCalendar(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar);

TInt AddProvCalendar(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar);

TInt AddProvAppointmentDailyRepeat(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUint& localuid);

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

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

// CTChangeStatusTest::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

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

//

void CTCalendarExportTest::Delete() 

    {

    }

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

// CTChangeStatusTest::RunMethodL

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

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

//

TInt CTCalendarExportTest::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. 

        //TRY( "SendMessage",    CTDeleteMessageTest::SendMessage ),

        ENTRY( "ExportAllProviderIter3",    	 	CTCalendarExportTest::ExportAll ),

        ENTRY( "ExportProviderIter3InvalidFormat",  CTCalendarExportTest::ExportProviderIter3InvalidFormat ),

        ENTRY( "ExportAllProviderIter3PosBased",    CTCalendarExportTest::ExportAllPosBased ),

		ENTRY( "ExportAllAsyncProviderIter3",    	CTCalendarExportTest::ExportAllAsync ),

		ENTRY( "ExportForGuidsProviderIter3",    	CTCalendarExportTest::ExportForGuids ),

		ENTRY( "ExportForGuidsAsyncProviderIter3",  CTCalendarExportTest::ExportForGuidsAsync ),

		ENTRY( "ExportForLuidsProviderIter3",    	CTCalendarExportTest::ExportForLuids ),

		ENTRY( "ExportForLuidsAsyncProviderIter3",  CTCalendarExportTest::ExportForLuidsAsync ),

		ENTRY( "ICALExportProviderIter3",     		CTCalendarExportTest::ICALExport ),

		ENTRY( "ICALExportAsyncProviderIter3",		CTCalendarExportTest::ICALExportAsync ),

        ENTRY( "ExportAllProviderFileIter3",    	 	CTCalendarExportTest::ExportAllFile ),

		ENTRY( "ExportAllAsyncProviderFileIter3",    	CTCalendarExportTest::ExportAllAsyncFile ),

		ENTRY( "ExportForGuidsProviderFileIter3",    	CTCalendarExportTest::ExportForGuidsFile ),

		ENTRY( "ExportForGuidsAsyncProviderFileIter3",  CTCalendarExportTest::ExportForGuidsAsyncFile ),

		ENTRY( "ExportForLuidsProviderFileIter3",    	CTCalendarExportTest::ExportForLuidsFile ),

		ENTRY( "ExportForLuidsAsyncProviderFileIter3",  CTCalendarExportTest::ExportForLuidsAsyncFile ),

		ENTRY( "ICALExportProviderFileIter3",     		CTCalendarExportTest::ICALExportFile ),

		ENTRY( "ICALExportAsyncProviderFileIter3",		CTCalendarExportTest::ICALExportAsyncFile ),        

		};

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

CCalCallback* CCalCallback::NewL(CActiveSchedulerWait* aWaitSchedular, TInt& aResult)

	{

	return new (ELeave) CCalCallback(aWaitSchedular, aResult);

	}

TInt CCalCallback::HandleNotifyL(TInt aCmdId,

									        TInt aEventId,

									        CLiwGenericParamList& aEventParamList,

									        const CLiwGenericParamList& aInParamList)

	{

	TInt pos = 0;

	TInt result = KErrNone;

    const TLiwGenericParam* output = aEventParamList.FindFirst( pos,_L8("ReturnValue"));

	if(output)

		{

		CLiwIterable* iterlist = output->Value().AsIterable();

		TInt returnItems = 0;

      	if(iterlist)

      		{

		    TLiwVariant data;

      		while ( iterlist->NextL(data) )

      			returnItems++;	

      		data.Reset();  

      		}

      	if(iEntryAdded == returnItems)	

      		iResult = KErrNone;

      	else

      		iResult = KErrGeneral;

		}

	if ( iWaitSchedular && iWaitSchedular->IsStarted())

		{

		iWaitSchedular->AsyncStop();

		}

		return 0;

	}

CTestAsync* CTestAsync::NewL()

	{

	CTestAsync* self = new (ELeave) CTestAsync();

	self->ConstructL();

	return self;

	}

CTestAsync::~CTestAsync()

	{

	Cancel();

	interface->Close();

	delete iServiceHandler;

	delete iCallback;

	if(iWaitSchedular->IsStarted())

		iWaitSchedular->AsyncStop();

	delete iWaitSchedular;

	}

void CTestAsync::ConstructL()

	{

	CActiveScheduler::Add(this);

	iWaitSchedular = new(ELeave) CActiveSchedulerWait();

	}

CTestAsync::CTestAsync() :

CActive(EPriorityStandard)

		{

		interface = NULL ;

		iResult = KErrGeneral;

		}

void CTestAsync::DoCancel()

	{

	}

void CTestAsync::RunL()

	{

	TestFunc();

	}

TInt CTestAsync::Result()

	{

	return iResult;

	}

void CTestAsync::Start(TInt flag, TInt option, TBool aICalFormat, TBool aAsync, TBool aPosBased, TBool aInvalidFormat)

	{

	iICalFormat = aICalFormat;

	iAsync = aAsync;

	iOption = flag;

	iFunc = option;

	iPosBased = aPosBased;

	iInvalidFormat = aInvalidFormat;

	if( iAsync )

		{

		SetActive();

		TRequestStatus* temp = &iStatus;

		User::RequestComplete(temp, KErrNone);

		iWaitSchedular->Start();	

		}

	else

		{

		TestFunc();

		}

	}

void CTestAsync::CancelNotification()

	{

	CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

	CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

   	CLiwDefaultMap* map = CLiwDefaultMap::NewL();

	CleanupStack::PushL(map);

	TLiwGenericParam element1;	

	element1.SetNameAndValueL(_L8("Type"),TLiwVariant(_L("CalendarEntry")));

	inparam->AppendL(element1);

	element1.Reset();

	TLiwGenericParam element2;	

	element2.SetNameAndValueL(_L8("TransactionID"), TLiwVariant(iTransactionId));

	inparam->AppendL(element2);

	element2.Reset();

    TLiwVariant filterparam(map);

	TLiwGenericParam element ;	

	element.SetNameAndValueL(_L8("Item"),filterparam);

	filterparam.Reset();

	inparam->AppendL(element);

	element.Reset();

    map->DecRef();

    CleanupStack::Pop(map);

	TRAPD(err1, interface->ExecuteCmdL(KCmdCancel, *inparam, *outparam, KLiwOptCancel ));

	inparam->Reset();

	outparam->Reset();

	}

TInt  CTCalendarExportTest::ExportAll(CStifItemParser& /*aItem*/)

	{	

	TInt result=KErrNone;

	if( result == KErrNone )

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		int option = 1;

		test->Start(flag, option, EFalse );

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }

TInt  CTCalendarExportTest::ExportProviderIter3InvalidFormat(CStifItemParser& /*aItem*/)

	{	

	TInt result=KErrNone;

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 1;

		int option = 1;

		test->Start(flag, option, EFalse, EFalse, EFalse, ETrue );

		result = test->Result();

		if(result == 1004)

			result = KErrNone;

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }

TInt  CTCalendarExportTest::ExportAllPosBased(CStifItemParser& /*aItem*/)

	{	

	TInt result=KErrNone;

	if( result == KErrNone )

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		int option = 1;

		test->Start(flag, option, EFalse, EFalse, ETrue);

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }

TInt  CTCalendarExportTest::ExportAllAsync(CStifItemParser& /*aItem*/)

	{	

	TInt result=KErrNone;

	if( result == KErrNone )

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		int option = 1;

    	test->Start(flag, option, EFalse, ETrue);

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }

TInt  CTCalendarExportTest::ExportForGuids(CStifItemParser& /*aItem*/)

	{	

	TInt result=KErrNone;

	if( result == KErrNone )

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		int option = 2;

		test->Start(flag, option, EFalse);

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }

TInt  CTCalendarExportTest::ExportForGuidsAsync(CStifItemParser& /*aItem*/)

	{	

	TInt result=KErrNone;

	if( result == KErrNone )

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		int option = 2;

		test->Start(flag,option,EFalse, ETrue);

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }

TInt  CTCalendarExportTest::ExportForLuids(CStifItemParser& /*aItem*/)

	{	

	TInt result=KErrNone;

	if( result == KErrNone )

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		int option = 3;

		test->Start(flag, option,EFalse);

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }    

TInt  CTCalendarExportTest::ExportForLuidsAsync(CStifItemParser& /*aItem*/)

	{	

	TInt result=KErrNone;

	if( result == KErrNone )

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		int option = 3;

		test->Start(flag, option,EFalse, ETrue);

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }    

TInt  CTCalendarExportTest::ICALExport(CStifItemParser& /*aItem*/)

	{	

	TInt result=KErrNone;

	if( result == KErrNone )

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		int option =1;

		test->Start(flag,option, ETrue);

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }    

	void Start(TInt flag, TInt option, TBool aICalFormat = EFalse, TBool aAsync = EFalse);

TInt  CTCalendarExportTest::ICALExportAsync(CStifItemParser& /*aItem*/)

	{	

	TInt result=KErrNone;

	if( result == KErrNone )

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		int option = 1;

		test->Start(flag,option, ETrue, ETrue);

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }    

TInt  CTCalendarExportTest::ExportAllFile(CStifItemParser& /*aItem*/)

	{	

	TInt result=KErrNone;

	if( result == KErrNone )

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 0;

		int option =1;

		test->Start(flag,option);

		result = test->Result();

		delete test;

		__UHEAP_MARKEND;

		}

	return result;

    }    

TInt  CTCalendarExportTest::ExportAllAsyncFile(CStifItemParser& /*aItem*/)

	{	

	TInt result=KErrNone;

	if( result == KErrNone )

		{

		__UHEAP_MARK;	

		CTestAsync* test = CTestAsync::NewL();

		int flag = 1;

		int option =1;