/*

* 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 "calendarheader.h"

#include "calendarservice.h"

#include "entryattributes.h"

#include <caluser.h>

#include <calalarm.h>

#include "tcalendarupdatetest.h"

#include "teststartconsolealarmserver.h"

//#include "calendarconstants.h"

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

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

// CTChangeStatusTest::Delete

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

// Called from destructor. 

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

//

void CTCalendarUpdateTest::Delete() 

    {

    }

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

// CTChangeStatusTest::RunMethodL

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

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

//

TInt CTCalendarUpdateTest::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( "UpdateAppointmentEntry",    	CTCalendarUpdateTest::UpdateAppointmentEntryL),

        ENTRY( "UpdateTodoEntry",       CTCalendarUpdateTest::UpdateTodoEntryL),

        ENTRY( "UpdateAnniversary",       CTCalendarUpdateTest::UpdateAnniversaryL),

        ENTRY( "UpdateDayEvent",       CTCalendarUpdateTest::UpdateDayEventL),

        ENTRY( "UpdateReminder",       CTCalendarUpdateTest::UpdateReminderL),

        ENTRY( "UpdateAppointmentEntryWithNewTime",       CTCalendarUpdateTest::UpdateAppointmentEntryWithNewTimeL),

        ENTRY( "UpdateAppointmentEntryWithNewAttendees",       CTCalendarUpdateTest::UpdateAppointmentEntryWithNewAttendeesL),

        ENTRY( "UpdateAppointmentEntryWithNewRepeat",    	CTCalendarUpdateTest::UpdateAppointmentEntryWithNewRepeatL),

        //ENTRY( "UpdateAppointmentEntryWithNewTimeAndAttendees",       CTCalendarUpdateTest::UpdateAppointmentEntryWithNewTimeAndAttendeesL),

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

/*

1. Change location, attendees, phone owner

2. Change start time of meeting - have to update alarm accordingly

3. Create a repeating entry

4. Create a repeating modifying entry

5. Modify the entire repeat sequence

6. Change alarm for parent and child

7. Set repeat and exeption dates

*/

_LIT(KTestCal1File                ,"C:updatecalfile1");

_LIT(KTestCal2File                ,"C:updatecalfile2");

_LIT(KString1                ,"New reminder");

TInt CTCalendarUpdateTest::UpdateAppointmentEntryL(CStifItemParser &aItem )

	{

    TInt result = KErrNone;

	__UHEAP_MARK;

	CCalendarService* service = CCalendarService::NewL();

	RemoveCalendarFile( service, KTestCal1File );

	AddCalendarFile( service, KTestCal1File );

	RPointerArray<TUIDSet> arruids(5);

	TUIDSet* uids = NULL;

	if(AddAppointmentWithAttendees(service, KTestCal1File, uids) == KErrNone && uids)

		{

		arruids.Append(uids);

		uids = NULL;

		}

	if ( arruids.Count() > 0 )

		{

	    RPointerArray<CCalEntry> entryArray;

	    CEntryAttributes* entryObj = CEntryAttributes::NewL();

	    TTime stTime(TDateTime(2007, EAugust, 8, 11, 0, 0, 0));

		entryObj->SetStartTimeL(stTime);

		TTime endTime(TDateTime(2007, EAugust, 8, 12, 0, 0, 0));

		entryObj->SetEndTimeL(endTime);

		CCalAlarm* alarm = CCalAlarm::NewL();

		TTime alarmTime(TDateTime(2007,EAugust, 8, 10, 30, 0, 0));

		entryObj->SetAlarm(alarmTime);

		delete alarm;

		service->GetListL( KTestCal1File, arruids[0]->iLocalUID , entryArray );

		if( entryArray.Count() == 1 )

			{

			entryObj->SetLocalUid( arruids[0]->iLocalUID );

			}

		TUIDSet* newuids = NULL;	

		entryArray.ResetAndDestroy();	

	    TRAPD( err, service->AddL(KTestCal1File,entryObj,newuids) );

	    delete newuids;

	    if ( err == KErrNone )

	    	{ 

	    	service->GetListL( KTestCal1File, arruids[0]->iLocalUID , entryArray );

	    	if( entryArray.Count() == 1 )

	    		{

	    		CCalAlarm* entryalarm = entryArray[0]->AlarmL();

	    		if( !(entryArray[0]->StartTimeL().TimeUtcL() == stTime && 

	    		    entryArray[0]->EndTimeL().TimeUtcL() == endTime &&

	    		    entryalarm->TimeOffset() == TTimeIntervalMinutes(30) ))

		    		{

		    		result = KErrGeneral;

		    		delete entryalarm;	

		    		}

		    	else

		    		delete entryalarm;

	    		}

	    	}

        else

	        {

	        result = KErrGeneral;		

	        }

		entryArray.ResetAndDestroy();

	    arruids.ResetAndDestroy();

	    delete entryObj;

	    }

		else

			result = KErrGeneral;	

	RemoveCalendarFile( service, KTestCal1File );

	delete service;

	__UHEAP_MARKEND;

	return result;

	}

TInt CTCalendarUpdateTest::UpdateTodoEntryL(CStifItemParser &aItem )

	{

	TInt result = KErrNone;

	__UHEAP_MARK;

	CCalendarService* service = CCalendarService::NewL();

	RemoveCalendarFile( service, KTestCal1File );

	AddCalendarFile( service, KTestCal1File );

	RPointerArray<TUIDSet> arruids(5);

	TUIDSet* uids = NULL;

	if(AddToDo(service, KTestCal1File, uids) == KErrNone && uids)

		{

		arruids.Append(uids);

		uids = NULL;

		}

	if ( arruids.Count() > 0 )

		{

	    RPointerArray<CCalEntry> entryArray;

	    CEntryAttributes* entryObj = CEntryAttributes::NewL();

		TTime endTime(TDateTime(2007, EAugust, 22, 0, 0, 0, 0));

		entryObj->SetEndTimeL(endTime);	    

		service->GetListL( KTestCal1File, arruids[0]->iLocalUID , entryArray );

		if( entryArray.Count() == 1 )

			{

			entryObj->SetLocalUid( arruids[0]->iLocalUID );

			}

		TCalLocalUid modifiedEntryId;	

		TUIDSet* entryUids = NULL;	

	    TRAPD( err, service->AddL(KTestCal1File,entryObj,entryUids) );

	    delete entryUids;

	    entryArray.ResetAndDestroy();

	    if ( err == KErrNone )

	    	{ 

	    	service->GetListL( KTestCal1File, arruids[0]->iLocalUID , entryArray );

	    	if( entryArray.Count() == 1 )

	    		{

	    		if( !(entryArray[0]->EndTimeL().TimeUtcL() == endTime ))

		    		{

		    		result = KErrGeneral;	

		    		}

		    	}

	    	}

        else

	        {

	        result = KErrGeneral;		

	        }

		entryArray.ResetAndDestroy();

	    arruids.ResetAndDestroy();

	    delete entryObj;

	    }

		else

			result = KErrGeneral;	

	RemoveCalendarFile( service, KTestCal1File );

	delete service;

	__UHEAP_MARKEND;

	return result;

	}

TInt CTCalendarUpdateTest::UpdateAnniversaryL(CStifItemParser &aItem )//try

	{

	TInt result = KErrNone;

	__UHEAP_MARK;

	CCalendarService* service = CCalendarService::NewL();

	RemoveCalendarFile( service, KTestCal1File );

	AddCalendarFile( service, KTestCal1File );

	RPointerArray<TUIDSet> arruids(5);

	TUIDSet* uids = NULL;

	if(AddAnny(service, KTestCal1File, uids) == KErrNone && uids)

		{

		arruids.Append(uids);

		uids = NULL;

		}

	if ( arruids.Count() > 0 )

		{

	    RPointerArray<CCalEntry> entryArray;

	    CEntryAttributes* entryObj = CEntryAttributes::NewL();

	    TCalTime stTime;

		stTime.SetTimeLocalFloatingL(TTime(TDateTime(2007, EDecember, 28, 0, 0, 0, 0)));

		TTime startTime(TDateTime(2007, EDecember, 28, 0, 0, 0, 0));

		entryObj->SetStartTimeL(startTime);	

		/*TCalRRule rrule(TCalRRule::EYearly);

		rrule.SetDtStart(stTime);

		rrule.SetInterval(1);

		TCalTime uTime;

		uTime.SetTimeLocalFloatingL(TCalTime::MaxTime());

		rrule.SetUntil(uTime);

		entryObj->SetRepeatRule(rrule); */   

		service->GetListL( KTestCal1File, arruids[0]->iLocalUID , entryArray );

		if( entryArray.Count() == 1 )

			{

			entryObj->SetLocalUid( arruids[0]->iLocalUID );

			}

		TUIDSet* uids = NULL;

		entryArray.ResetAndDestroy();		

	    TRAPD( err, service->AddL(KTestCal1File,entryObj,uids) );

	    delete uids;

	    if ( err == KErrNone )

	    	{ 

	    	service->GetListL( KTestCal1File, arruids[0]->iLocalUID , entryArray );

	    	if( entryArray.Count() == 1 )

	    		{

		    	TCalRRule rRule;

	    		entryArray[0]->GetRRuleL( rRule );

	    		TCalTime utTime;

				utTime.SetTimeLocalFloatingL(TTime(TDateTime(2100, EDecember, 28, 0, 0, 0, 0)));

	    		if( !( entryArray[0]->StartTimeL().TimeLocalL() == stTime.TimeLocalL() ) && rRule.Until().TimeLocalL() == utTime.TimeLocalL())

		    		{

		    		result = KErrGeneral;	

		    		}

		    	}

	    	}

        else

	        {

	        result = KErrGeneral;		

	        }

		entryArray.ResetAndDestroy();

	    arruids.ResetAndDestroy();

	    delete entryObj;

	    }

		else

			result = KErrGeneral;	

	RemoveCalendarFile( service, KTestCal1File );

	delete service;

	__UHEAP_MARKEND;

	return result;

	}

TInt CTCalendarUpdateTest::UpdateDayEventL(CStifItemParser &aItem )//try

	{

	TInt result = KErrNone;

	__UHEAP_MARK;

	CCalendarService* service = CCalendarService::NewL();

	RemoveCalendarFile( service, KTestCal1File );

	AddCalendarFile( service, KTestCal1File );

	RPointerArray<TUIDSet> arruids(5);

	TUIDSet* uids = NULL;

	if(AddEvent(service, KTestCal1File, uids) == KErrNone && uids)

		{

		arruids.Append(uids);

		uids = NULL;

		}

	if ( arruids.Count() > 0 )

		{

	    RPointerArray<CCalEntry> entryArray;

	    CEntryAttributes* entryObj = CEntryAttributes::NewL();

	    entryObj->SetDescriptionL(_L("Day event modified"));

	    entryObj->SetPriority(2);	

		service->GetListL( KTestCal1File, arruids[0]->iLocalUID , entryArray );

		if( entryArray.Count() == 1 )

			{

			entryObj->SetLocalUid( arruids[0]->iLocalUID );

			}

		TUIDSet* uids = NULL;		

	    TRAPD( err, service->AddL(KTestCal1File,entryObj,uids) );

	    delete uids;

	    entryArray.ResetAndDestroy();

	    if ( err == KErrNone )

	    	{ 

	    	service->GetListL( KTestCal1File, arruids[0]->iLocalUID , entryArray );

	    	if( entryArray.Count() == 1 )

	    		{

	    		if( !( entryArray[0]->DescriptionL().CompareF(_L("Day event modified")) == 0 && entryArray[0]->PriorityL() == 2 ) )

		    		{

		    		result = KErrGeneral;	

		    		}

		    	}

	    	}

        else

	        {

	        result = KErrGeneral;		

	        }

		entryArray.ResetAndDestroy();

	    arruids.ResetAndDestroy();

	    delete entryObj;

	    }

		else

			result = KErrGeneral;	

	RemoveCalendarFile( service, KTestCal1File );

	delete service;

	__UHEAP_MARKEND;

	return result;

	}

TInt CTCalendarUpdateTest::UpdateReminderL(CStifItemParser &aItem )

	{

	TInt result = KErrNone;

	__UHEAP_MARK;

	CCalendarService* service = CCalendarService::NewL();

	RemoveCalendarFile( service, KTestCal1File );

	AddCalendarFile( service, KTestCal1File );

	RPointerArray<TUIDSet> arruids(5);

	TUIDSet* uids = NULL;

	if(AddReminder(service, KTestCal1File, uids) == KErrNone && uids)

		{

		arruids.Append(uids);

		uids = NULL;

		}

	if ( arruids.Count() > 0 )

		{

	    RPointerArray<CCalEntry> entryArray;

	    CEntryAttributes* entryObj = CEntryAttributes::NewL();

	    entryObj->SetSummaryL(KString1);	    

	    TTime stTime(TDateTime(2007, EJuly, 23, 11, 30, 0, 0));

		entryObj->SetStartTimeL(stTime);

		service->GetListL( KTestCal1File, arruids[0]->iLocalUID , entryArray );

		if( entryArray.Count() == 1 )

			{

			entryObj->SetLocalUid( arruids[0]->iLocalUID );

			}

		TUIDSet* uids = NULL;		

	    TRAPD( err, service->AddL(KTestCal1File,entryObj,uids) );

	    delete uids;

	    entryArray.ResetAndDestroy();

	    if ( err == KErrNone )

	    	{ 

	    	service->GetListL( KTestCal1File, arruids[0]->iLocalUID , entryArray );

	    	if( entryArray.Count() == 1 )

	    		{

	    		if( !( entryArray[0]->SummaryL().CompareF( KString1 ) == 0 && entryArray[0]->StartTimeL().TimeUtcL() == stTime))

		    		{

		    		result = KErrGeneral;	

		    		}

	    		}

	    	}

        else

	        {

	        result = KErrGeneral;		

	        }

		entryArray.ResetAndDestroy();

	    arruids.ResetAndDestroy();

	    delete entryObj;

	    }

		else

			result = KErrGeneral;	

	RemoveCalendarFile( service, KTestCal1File );

	delete service;

	__UHEAP_MARKEND;

	return result;

	}

TInt CTCalendarUpdateTest::UpdateAppointmentEntryWithNewTimeL(CStifItemParser &aItem )

	{

	TInt result = KErrNone;

	__UHEAP_MARK;

	CCalendarService* service = CCalendarService::NewL();

	RemoveCalendarFile( service, KTestCal1File );

	AddCalendarFile( service, KTestCal1File );

	RPointerArray<TUIDSet> arruids(5);

	TUIDSet* uids = NULL;

	if(AddRepeatingAppointmentEntryL(service, KTestCal1File, uids) == KErrNone && uids)

		{

		arruids.Append(uids);

		uids = NULL;

		}

	if ( arruids.Count() > 0 )

		{

	    RPointerArray<CCalEntry> entryArray;