1 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "calentryimpl.h"

    17 

    18 #include "calclient.h"

    19 #include "agsalarm.h"

    20 #include "agmattachment.h"

    21 #include "agmdate.h"

    22 #include "agmentry.h"

    23 #include "agmpanic.h"

    24 #include "agmcategory.h"

    25 #include "agmattendee.h"

    26 #include "agmcontent.h"

    27 #include <calalarm.h>

    28 #include "calcategoryimpl.h"

    29 #include <calcontent.h>

    30 #include <calrrule.h>

    31 #include <calsession.h>

    32 #include "calsessionimpl.h"

    33 #include "caluserimpl.h"

    34 

    35 const TInt KAttendeeGranularity = 2;

    36 const TInt KCategoryGranularity = 1;

    37 const TInt KAttachmentGranularity = 1;

    38 

    39 

    40 CCalEntryImpl::~CCalEntryImpl()

    41 	{

    42 	if(iSessionImpl)

    43 		{

    44 		iSessionImpl->DecrementReferenceCount();

    45 		}

    46 

    47 	if (iLiteEntry)

    48  		{

    49 		iLiteEntry->DecrementRefCount();

    50  		}

    51 	if(iCalAttachmentList)

    52 		{

    53 		iCalAttachmentList->ResetAndDestroy();

    54 		delete iCalAttachmentList; 	

    55 		}

    56 	if(iCalAttendeeList)

    57 		{

    58 		iCalAttendeeList->ResetAndDestroy();

    59 		delete iCalAttendeeList;

    60 		}

    61 	if(iCalCategoryList)

    62 		{

    63 		iCalCategoryList->ResetAndDestroy();

    64 		delete iCalCategoryList;

    65 		}

    66 	delete iCalOrganizer;

    67 	delete iFullEntry;

    68 	}

    69 

    70 CCalEntryImpl::CCalEntryImpl()

    71 	{

    72 	}

    73 

    74 CCalEntryImpl::CCalEntryImpl(CAgnEntry& aEntry, CCalSessionImpl& aSessionImpl)

    75 	: iFullEntry(&aEntry), iSessionImpl(&aSessionImpl)

    76 	{

    77 	iSessionImpl->IncrementReferenceCount();

    78 	}

    79 

    80 

    81 CCalEntryImpl::CCalEntryImpl(CCalLiteEntry& aEntry, CCalSessionImpl& aSessionImpl)

    82 	: iLiteEntry(&aEntry), iSessionImpl(&aSessionImpl)

    83  	{

    84  	iSessionImpl->IncrementReferenceCount();

    85 	iLiteEntry->IncrementRefCount();

    86  	}

    87 

    88 void CCalEntryImpl::ClearSimpleEntry()

    89 	{

    90 	if (iSessionImpl && iLiteEntry)

    91 		{

    92 		iLiteEntry->DecrementRefCount();

    93 		iLiteEntry = NULL;

    94 		}

    95 	}

    96 	

    97 CCalEntryImpl* CCalEntryImpl::NewL(CCalEntry::TType aType, HBufC8* aUid, CCalEntry::TMethod aMethod, TUint aSeqNum)

    98 	{

    99 	__ASSERT_ALWAYS(aUid && aUid->Length() > 0, User::Leave(KErrArgument));

   100 

   101 	CCalEntryImpl* self = new (ELeave) CCalEntryImpl();

   102 	CleanupStack::PushL(self);

   103 	self->ConstructL(aType, aUid, aMethod, aSeqNum); // takes ownership of aUid

   104 	CleanupStack::Pop(self);

   105 	return self;

   106 	}

   107 

   108 CCalEntryImpl* CCalEntryImpl::NewL(CCalEntry::TType aType, HBufC8* aUid, CCalEntry::TMethod aMethod,

   109 			TUint aSeqNum, const TCalTime& aRecurrenceId, CalCommon::TRecurrenceRange aRange)

   110 	{

   111 	__ASSERT_ALWAYS(aUid && aUid->Length() > 0, User::Leave(KErrArgument));

   112 

   113 	CCalEntryImpl* self = new (ELeave) CCalEntryImpl();

   114 	CleanupStack::PushL(self);

   115 	self->ConstructL(aType, aUid, aMethod, aSeqNum, CalUtils::TCalTimeToTAgnCalendarTimeL(aRecurrenceId), aRange);

   116 	   // takes ownership of aUid

   117 	CleanupStack::Pop(self);

   118 	return self;

   119 	}

   120 

   121 CCalEntryImpl* CCalEntryImpl::NewL(CAgnEntry& aEntry, CCalSessionImpl& aSessionImpl)

   122 	{

   123 	CCalEntryImpl* self = new (ELeave) CCalEntryImpl(aEntry, aSessionImpl);

   124 	return self;

   125 	}

   126 

   127 CCalEntryImpl* CCalEntryImpl::NewL(CCalLiteEntry& aEntry, CCalSessionImpl& aSessionImpl)

   128 	{

   129 	CCalEntryImpl* self = new (ELeave) CCalEntryImpl(aEntry, aSessionImpl);

   130 	return self;

   131 	}

   132 

   133 void CCalEntryImpl::ConstructL(CCalEntry::TType aType, HBufC8* aUid, CCalEntry::TMethod aMethod, TUint aSeqNum, const TAgnCalendarTime& aRecurrenceId, CalCommon::TRecurrenceRange aRange)

   134 	{

   135 	// Create appropriate CAgnEntry type child entry.

   136 	iFullEntry = CAgnEntry::NewL(aType, aUid, aMethod, aSeqNum, aRecurrenceId, aRange); // takes ownership of aUid

   137 	}

   138 

   139 

   140 void CCalEntryImpl::ConstructL(CCalEntry::TType aType, HBufC8* aUid, CCalEntry::TMethod aMethod, TUint aSeqNum)

   141 	{

   142 	// Create appropriate CAgnEntry type parent entry.

   143 	iFullEntry = CAgnEntry::NewL(aType, aUid, aMethod,aSeqNum);

   144 	}

   145 

   146 void CCalEntryImpl::LoadFullEntryL()

   147 	{

   148 	if (iLiteEntry)

   149 		{

   150 		// iFullEntry should be NULL at this point

   151 		__ASSERT_DEBUG(iFullEntry == NULL, User::Leave(KErrCorrupt));

   152 		

   153 		// extract full CAgnEntry from TAgnLiteEntry and store it in iFullEntry

   154 		TCalLocalUid id = iLiteEntry->LiteEntry().LocalUid();

   155 		iFullEntry = iSessionImpl->Server().FetchEntryL(id, iSessionImpl->FileId());

   156 		__ASSERT_ALWAYS(iFullEntry, User::Leave(KErrNotFound));

   157 		iFullEntry->SetCollectionId(iLiteEntry->LiteEntry().CollectionId());

   158 		ClearSimpleEntry();

   159 		}

   160 	}

   161 

   162 // return the CAgnEntry associated with this entry, loading it from the server if necessary

   163 CAgnEntry* CCalEntryImpl::GetFullEntryL()

   164 	{

   165 	LoadFullEntryL();

   166 	return iFullEntry;

   167 	}

   168 

   169 void CCalEntryImpl::PopulateCategoryListL()

   170 	{

   171 	if (!iCalCategoryList)

   172 		{

   173 		LoadFullEntryL();

   174 		iCalCategoryList = new (ELeave) RPointerArray<CCalCategory>(KCategoryGranularity);

   175 

   176 		const TInt KCategoryCount = iFullEntry->CategoryCount();

   177 		for (TInt i = 0; i < KCategoryCount; ++i)

   178 			{

   179 			CAgnCategory& agnCategory = iFullEntry->FetchCategory(i); // ownership not taken

   180 			CCalCategoryImpl* impl = CCalCategoryImpl::NewL(&agnCategory); // doesn't take ownership of agnCategory

   181 			CleanupStack::PushL(impl);

   182 			CCalCategory* category = CCalCategory::NewL(impl); // takes ownership of impl

   183 			CleanupStack::Pop(impl);

   184 			CleanupStack::PushL(category);

   185 			iCalCategoryList->AppendL(category); // takes ownership of category

   186 			CleanupStack::Pop(category);

   187 			}

   188 		}

   189 	}

   190 

   191 void CCalEntryImpl::PopulateAttendeeListL()

   192 	{

   193 	if(!iCalAttendeeList)

   194 		{

   195 		LoadFullEntryL();

   196 

   197 		iCalAttendeeList = new(ELeave) RPointerArray<CCalAttendee>(KAttendeeGranularity);

   198 

   199 		const TInt KAttendeeCount = iFullEntry->AttendeeCount();

   200 		for(TInt i = 0; i < KAttendeeCount; ++i)

   201 			{

   202 			CAgnAttendee& agnAttendee = iFullEntry->FetchAttendee(i);

   203 			

   204 			CCalUserImpl* impl = CCalUserImpl::NewL(&agnAttendee);	// doesn't take ownership of agnAttendee

   205 			CleanupStack::PushL(impl);

   206 			CCalAttendee* calAttendee = CCalAttendee::NewL(impl);	// takes ownership of impl

   207 			CleanupStack::Pop(impl);

   208 			

   209 			CleanupStack::PushL(calAttendee);

   210 			iCalAttendeeList->AppendL(calAttendee);

   211 			CleanupStack::Pop(calAttendee);

   212 			}

   213 		}

   214 	}

   215 

   216 

   217 void CCalEntryImpl::AddAttendeeL(CCalAttendee* aAttendee)

   218 	{

   219     if (!aAttendee)

   220         {

   221         User::Leave( KErrArgument );

   222         }

   223 

   224 	CleanupStack::PushL(aAttendee);

   225 	__ASSERT_ALWAYS(aAttendee != NULL, User::Leave(KErrArgument));

   226 	PopulateAttendeeListL();

   227 

   228 	CCalUserImpl* userImpl = aAttendee->Impl();

   229 	CAgnAttendee* attendee = userImpl->Attendee();

   230 	

   231 	// add attendee to CAgnEntry (no longer owned by CCalAttendee)

   232 	userImpl->SetOwnsCAgnAttendee(EFalse);		

   233 	iFullEntry->AddAttendeeL(attendee);		

   234 	

   235 	// store attendee in attendee array too

   236 	iCalAttendeeList->AppendL(aAttendee);

   237 	CleanupStack::Pop(aAttendee);

   238 	}

   239 

   240 RPointerArray<CCalAttendee>& CCalEntryImpl::AttendeesL()

   241 	{

   242 	PopulateAttendeeListL();

   243 	return *iCalAttendeeList;

   244 	}

   245 

   246 void CCalEntryImpl::DeleteAttendeeL(TInt aIndex)

   247 	{

   248 	LoadFullEntryL();

   249 

   250 	if(iCalAttendeeList)

   251 		{

   252 		if (aIndex < 0 || aIndex >= iCalAttendeeList->Count())

   253 			{

   254 			User::Leave(KErrArgument);

   255 			}

   256 		delete (*iCalAttendeeList)[aIndex];

   257 		iCalAttendeeList->Remove(aIndex);

   258 		}

   259 

   260 	iFullEntry->DeleteAttendee(aIndex);

   261 	}

   262 

   263 void CCalEntryImpl::SetOrganizerL(CCalUser* aUser)

   264 	{

   265 	CleanupStack::PushL(aUser);

   266 	__ASSERT_ALWAYS(aUser != NULL, User::Leave(KErrArgument));

   267 	LoadFullEntryL();

   268 	

   269 	aUser->Impl()->SetOwnsCAgnAttendee(EFalse);

   270 	iFullEntry->SetOrganizerL(aUser->Impl()->Attendee());	//	takes ownership of user immediately

   271 

   272 	delete iCalOrganizer;

   273 	iCalOrganizer = aUser;

   274 	CleanupStack::Pop(aUser);

   275 	}

   276 

   277 void CCalEntryImpl::SetPhoneOwnerL(const CCalUser* aOwner)

   278 	{

   279 	__ASSERT_ALWAYS(aOwner != NULL, User::Leave(KErrArgument));

   280 	LoadFullEntryL();

   281 	CCalUserImpl* userImpl = aOwner->Impl();

   282 	iFullEntry->SetPhoneOwnerL(userImpl->Attendee());

   283 	}

   284 

   285 CCalUser* CCalEntryImpl::PhoneOwnerL()

   286 	{

   287 	LoadFullEntryL();

   288 

   289 	CAgnAttendee* agnPhoneOwner = iFullEntry->PhoneOwner();

   290 

   291 	if(agnPhoneOwner)

   292 		{	

   293 		//check to see if phone owner is the organizer

   294 		if(OrganizerL())

   295 			{

   296 			if(agnPhoneOwner == iCalOrganizer->Impl()->Attendee())

   297 				{

   298 				return iCalOrganizer;

   299 				}

   300 			}

   301 

   302 		PopulateAttendeeListL();

   303 		

   304 		// see if the phone owner is one of the other attendees

   305 		const TInt KAttendeeCount = iCalAttendeeList->Count();

   306 		for(TInt i = 0; i < KAttendeeCount; ++i)

   307 			{

   308 			CCalAttendee* calAttendee = (*iCalAttendeeList)[i];

   309 			if(agnPhoneOwner == calAttendee->Impl()->Attendee())

   310 				{

   311 				return calAttendee;

   312 				}

   313 			}

   314 		}

   315 	return NULL;

   316 	}

   317 

   318 

   319 CCalUser* CCalEntryImpl::OrganizerL()

   320 	{

   321 	LoadFullEntryL();

   322 	if( ! iCalOrganizer)

   323 		{

   324 		CAgnAttendee* organizer = iFullEntry->Organizer();

   325 		

   326 		if(organizer)

   327 			{

   328 			CCalUserImpl* impl = CCalUserImpl::NewL(organizer);

   329 			CleanupStack::PushL(impl);

   330 			impl->SetOwnsCAgnAttendee(EFalse);

   331 			iCalOrganizer = CCalUser::NewL(impl);

   332 			CleanupStack::Pop(impl);

   333 			}

   334 		}

   335 

   336 	return iCalOrganizer;

   337 	}

   338 

   339 CTzRules* CCalEntryImpl::GetTzRulesL()

   340 	{

   341 	CAgnRptDef* rptDef = SimpleEntry()->RptDef();

   342 	

   343 	if (rptDef == NULL)

   344 		{

   345 		return NULL;

   346 		}

   347 	return rptDef->CloneTzRulesL();

   348 	}

   349 

   350 void CCalEntryImpl::SetTzRulesL(const CTzRules& aTzRules)

   351 	{

   352 	LoadFullEntryL();

   353 	

   354 	if (TimeMode() == MAgnCalendarTimeMode::EFloating)

   355 		{

   356 		User::Leave(KErrArgument);

   357 		}

   358 

   359 	CAgnRptDef* rptDef = SimpleEntry()->RptDef(); // doesn't take ownership

   360 	

   361 	if (!rptDef)

   362 		{

   363 		User::Leave(KErrNotFound);

   364 		}

   365    

   366 	rptDef->SetTimeZoneL(aTzRules); // rptDef doesn't take ownership of aTzRules

   367 	}

   368 

   369 void CCalEntryImpl::SetTzRulesL()

   370 	{

   371 	LoadFullEntryL();

   372 	

   373 	if (TimeMode() == MAgnCalendarTimeMode::EFloating)

   374 		{

   375 		User::Leave(KErrArgument);

   376 		}

   377 

   378 	CAgnRptDef* rptDef = SimpleEntry()->RptDef();

   379 	if (rptDef == NULL)

   380 		{

   381 		User::Leave(KErrNotFound);

   382 		}

   383 	rptDef->SetTimeZoneL();

   384 	}

   385 

   386 void CCalEntryImpl::SetRDatesL(const RArray<TCalTime>& aRDates)

   387 	{

   388 	LoadFullEntryL();

   389 	SetDatesL(ETrue, aRDates);

   390 	}

   391 

   392 void CCalEntryImpl::SetExceptionDatesL(const RArray<TCalTime>& aExDates)

   393 	{

   394 	LoadFullEntryL();

   395 	

   396 	if (iFullEntry->RptDef() == NULL)

   397 		{

   398 		User::Leave(KErrNotFound);

   399 		}

   400 

   401 	SetDatesL(EFalse, aExDates);

   402 	}

   403 	

   404 //if aDateType is ETrue, add dates to sporadic date list

   405 //if aDateType is EFalse, add dates to exception list

   406 void CCalEntryImpl::SetDatesL(TBool aDateType, const RArray<TCalTime>& aDates)

   407 	{

   408 	const TCalTime::TTimeMode KEntryTimeMode = static_cast<TCalTime::TTimeMode>(TimeMode());

   409 	const TInt KDateCount = aDates.Count();

   410 	TInt i = 0;

   411 	for (i = 0; i < KDateCount; i++)

   412 		{

   413 		if (aDates[i].TimeMode() != KEntryTimeMode)

   414 			{

   415 			User::Leave(KErrArgument);

   416 			}

   417 		}

   418 

   419 	CAgnRptDef* rptDef = SimpleEntry()->RptDef();

   420 

   421 	TBool entryHasNoRptDef(rptDef == NULL);

   422 	if (entryHasNoRptDef)

   423 		{

   424 		rptDef = CAgnRptDef::NewL(*SimpleEntry());

   425 		CleanupStack::PushL(rptDef);

   426 		}

   427 	else

   428 		{

   429 		if (aDateType)

   430 			{

   431 			rptDef->RemoveAllSporadicDates();

   432 			}

   433 		else

   434 			{

   435 			rptDef->RemoveAllExceptions();

   436 			}

   437 		}

   438 

   439 	// store the dates

   440 	for (i = 0; i < KDateCount; ++i)

   441 		{

   442 		TAgnCalendarTime agnTime = CalUtils::TCalTimeToTAgnCalendarTimeL(aDates[i]);

   443 		if (aDateType)

   444 			{

   445 			rptDef->AddSporadicDateL(agnTime);

   446 			}

   447 		else

   448 			{

   449 			rptDef->AddExceptionL(agnTime);

   450 			}

   451 		}

   452 

   453 	// if the rptDef didn't exist in the entry already, add it

   454 	if (entryHasNoRptDef)

   455 		{

   456 		iFullEntry->SetRptDefL(*rptDef); // makes a copy of rptDef

   457 		CleanupStack::PopAndDestroy(rptDef);

   458 		}

   459 	}

   460 

   461 void CCalEntryImpl::GetRDatesL(RArray<TCalTime>& aRDates)

   462 	{

   463 	aRDates.Reset();

   464 	const CAgnRptDef* KRptDef = SimpleEntry()->RptDef();

   465 	if (KRptDef)

   466 		{

   467 		FetchDatesL(KRptDef->SporadicDateList(), aRDates);

   468 		}

   469 	}

   470 

   471 void CCalEntryImpl::GetExceptionDatesL(RArray<TCalTime>& aExDates)

   472 	{

   473 	aExDates.Reset();

   474 	const CAgnRptDef* KRptDef = SimpleEntry()->RptDef();

   475 	if (KRptDef)

   476 		{

   477 		FetchDatesL(KRptDef->Exceptions(), aExDates);

   478 		}

   479 	}

   480 	

   481 void CCalEntryImpl::FetchDatesL(const RArray<TAgnCalendarTime>* aDateList, RArray<TCalTime>& aRDates)

   482 	{

   483 	// aDateList may be NULL

   484 	if (aDateList)

   485 		{

   486 		const TInt KDateCount = aDateList->Count();

   487 		for (TInt i = 0; i < KDateCount; ++i)

   488 			{

   489 			TCalTime calTime = CalUtils::TAgnCalendarTimeToTCalTimeL((*aDateList)[i]);

   490 			aRDates.AppendL(calTime);

   491 			}

   492 		}

   493 	}

   494 

   495 CCalEntry::TMethod CCalEntryImpl::MethodL()

   496 	{

   497 	LoadFullEntryL();

   498 	return iFullEntry->Method();

   499 	}

   500 	

   501 TCalTime CCalEntryImpl::RecurrenceIdL()

   502 	{

   503 	// If this entry has been committed to store, the Rec-Id can be retrieved from the

   504 	// CAgnEntryModel by passing the appropraite CAgnEntry.

   505 	// Else try to retrieve it from CAgnEntry's temporary GS data.

   506 

   507 	LoadFullEntryL();

   508 	return CalUtils::TAgnCalendarTimeToTCalTimeL(iFullEntry->RecurrenceId());

   509 	}

   510 	

   511 CalCommon::TRecurrenceRange CCalEntryImpl::RecurrenceRangeL()

   512    	{

   513    	LoadFullEntryL();

   514 	return iFullEntry->RecurrenceRange();

   515    	}

   516 	

   517 const TDesC8& CCalEntryImpl::UidL()

   518 	{

   519 	LoadFullEntryL();

   520 	// Does not transfer ownership

   521 	if(iFullEntry->Guid() == KNullDesC8)

   522 		{

   523 		// this entry must be a child entry whose GUID has not been loaded

   524 		__ASSERT_ALWAYS(iFullEntry->GsDataType() == CGsData::EChild, User::Leave(KErrCorrupt)); 

   525 		

   526 		// get parent entry

   527 		TCalLocalUid parentId = iFullEntry->ParentId();

   528 		CAgnEntry* parentEntry = iSessionImpl->Server().FetchEntryL(parentId, iSessionImpl->FileId());

   529 		__ASSERT_ALWAYS(parentEntry, User::Leave(KErrNotFound));

   530 		CleanupStack::PushL(parentEntry);

   531 		HBufC8* guidHbuf = parentEntry->Guid().AllocL();

   532 		CleanupStack::PopAndDestroy(parentEntry);	

   533 

   534 		iFullEntry->SetGuid(guidHbuf);

   535 		}

   536 		

   537 	return iFullEntry->Guid();

   538 	}

   539 

   540 

   541 TInt CCalEntryImpl::SequenceNumberL()

   542 	{

   543 	LoadFullEntryL();

   544 	return iFullEntry->SequenceNumber();

   545 	}

   546 

   547 

   548 void CCalEntryImpl::SetMethodL(CCalEntry::TMethod aMethod)

   549 	{

   550 	LoadFullEntryL();

   551 	iFullEntry->SetMethod(aMethod);

   552 	}

   553 

   554 const RPointerArray<CCalCategory>& CCalEntryImpl::CategoryListL()

   555 	{

   556 	PopulateCategoryListL();

   557 

   558 	return *iCalCategoryList;

   559 	}

   560 

   561 void CCalEntryImpl::AddCategoryL(CCalCategory* aCategory)

   562 	{

   563 	CleanupStack::PushL(aCategory);

   564 	__ASSERT_ALWAYS(aCategory != NULL, User::Leave(KErrArgument));

   565 	

   566  	PopulateCategoryListL();

   567 

   568 	// add the category to the list

   569  	iCalCategoryList->AppendL(aCategory);

   570 	CleanupStack::Pop(aCategory);

   571 

   572 	TInt err(KErrNone);

   573 

   574 	// add category to CAgnEntry

   575 	TRAP(err , iFullEntry->AddCategoryL( aCategory->Impl()->AgnCategory() ) ); // this can leave before taking ownership

   576 

   577  	if (err != KErrNone)

   578  		{

   579  		delete (*iCalCategoryList)[iCalCategoryList->Count() - 1];

   580  		iCalCategoryList->Remove(iCalCategoryList->Count() - 1);

   581  		User::Leave(err);

   582  		}

   583 

   584  	aCategory->Impl()->SetOwnAgnCategory(EFalse);

   585 	}

   586 

   587 void CCalEntryImpl::DeleteCategoryL(TInt aIndex)

   588 	{

   589 	LoadFullEntryL();

   590 	

   591 	if (aIndex < 0 || aIndex >= iFullEntry->CategoryCount())

   592 		{

   593 		User::Leave(KErrArgument);

   594 		}

   595 			

   596 	iFullEntry->DeleteCategory(aIndex);

   597 	if(iCalCategoryList)

   598 		{

   599 		delete (*iCalCategoryList)[aIndex];

   600 		iCalCategoryList->Remove(aIndex);

   601 		

   602 		// check count of CAgnCategory and CCalCategory is the same

   603 		__ASSERT_DEBUG(iCalCategoryList->Count() == iFullEntry->CategoryCount(), Panic(EAgmErrCategoryCountCorrupt)); 

   604 		}

   605 	}

   606 

   607 TBool CCalEntryImpl::GetRRuleL(TCalRRule& aRule)

   608 	{

   609 	const CAgnRptDef* KRptDef = SimpleEntry()->RptDef();

   610 	if (KRptDef == NULL || KRptDef->RRule() == NULL)

   611 		{

   612 		return EFalse;

   613 		}

   614 

   615 	const TAgnRpt* KRpt = KRptDef->RRule();

   616 

   617 	// get the DTSTART property

   618 	if (SimpleEntry()->Type() == CCalEntry::ETodo)

   619 		{

   620 		aRule.SetDtStart(EndTimeL());

   621 		}

   622 	else

   623 		{

   624 		aRule.SetDtStart(StartTimeL());

   625 		}

   626 

   627 	TInt repCount = 0;

   628 	TCalTime untilCaltime = CalUtils::TAgnCalendarTimeToTCalTimeL(KRpt->UntilTimeL());

   629 		

   630 	if (untilCaltime.TimeLocalL() == TCalTime::MaxTime())

   631 		{

   632 		//Idealy, only UTC maximum time should be used to indicate the repeating forever. However, for a behaviour compatible reason,

   633 		//when the client sets local or UTC repeating until time to be maximum time, it is treated as repeating forever. 

   634 		untilCaltime.SetTimeUtcL(TCalTime::MaxTime());

   635 		}

   636 	else

   637 		{

   638 		repCount = KRpt->InstanceCountL();

   639 		}

   640 

   641 	aRule.SetUntilAndCount(untilCaltime, repCount);	

   642 	

   643 	// get the INTERVAL property

   644 	aRule.SetInterval(KRpt->Interval());

   645 

   646 	// get the TCalRRule's type, and type-specific data

   647 	switch (KRpt->Type())

   648 		{

   649 		case TAgnRpt::EDaily:

   650 			aRule.SetType(TCalRRule::EDaily);

   651 			break;

   652 		case TAgnRpt::EYearlyByDate:

   653 			aRule.SetType(TCalRRule::EYearly);

   654 			break;

   655 		case TAgnRpt::EYearlyByDay:

   656 			{

   657 			aRule.SetType(TCalRRule::EYearly);

   658 

   659 			TDay day;

   660 			TAgnRpt::TWeekInMonth weekInMonth;

   661 			TMonth month;

   662 			TInt year;

   663 

   664 			const TAgnYearlyByDayRpt* KYearlyRpt = static_cast<const TAgnYearlyByDayRpt*>(KRpt);

   665 			KYearlyRpt->GetStartDayL(day, weekInMonth, month, year);

   666 			TInt8 week = CalUtils::AgnWeekInMonthToWeekNumberL(weekInMonth);

   667 			TCalRRule::TDayOfMonth dayOfMonth(day, week);

   668 

   669 			RArray<TCalRRule::TDayOfMonth> dayOfMonthArray;

   670 			CleanupClosePushL(dayOfMonthArray);

   671 			dayOfMonthArray.AppendL(dayOfMonth);

   672 			aRule.SetByDay(dayOfMonthArray);

   673 			CleanupStack::PopAndDestroy(&dayOfMonthArray);

   674 

   675 			RArray<TMonth> monthArray;

   676 			CleanupClosePushL(monthArray);

   677 			monthArray.AppendL(month);

   678 			aRule.SetByMonth(monthArray);

   679 			CleanupStack::PopAndDestroy(&monthArray);

   680 			}

   681 			break;

   682 		case TAgnRpt::EWeekly:

   683 			{

   684 			aRule.SetType(TCalRRule::EWeekly);

   685 			const TAgnWeeklyRpt* KWeeklyRpt = static_cast<const TAgnWeeklyRpt*>(KRpt);

   686 			aRule.SetWkSt(KWeeklyRpt->FirstDayOfWeek());

   687 

   688 			RArray<TDay> array;

   689 			CleanupClosePushL(array);

   690 			TDay day = EMonday;

   691 			while (day <= ESunday)

   692 				{

   693 				if (KWeeklyRpt->IsDaySet(day))

   694 					{

   695 					array.AppendL(day);

   696 					}

   697 				day = static_cast<TDay>(static_cast<TInt>(day) + 1);

   698 				}

   699 			aRule.SetByDay(array);

   700 			CleanupStack::PopAndDestroy(&array);

   701 			}

   702 			break;

   703 		case TAgnRpt::EMonthlyByDays:

   704 			{

   705 			aRule.SetType(TCalRRule::EMonthly);

   706 			const TAgnMonthlyByDaysRpt* KMonthlyByDayRpt = static_cast<const TAgnMonthlyByDaysRpt*>(KRpt);

   707 

   708 			RArray<TCalRRule::TDayOfMonth> dayArray;

   709 			CleanupClosePushL(dayArray);

   710 			

   711 			TAgnRpt::TWeekInMonth week = TAgnRpt::EFirst;

   712 			while (week <= TAgnRpt::ELast)

   713 				{

   714 				TDay day = EMonday;

   715 				while (day <= ESunday)

   716 					{

   717 					if (KMonthlyByDayRpt->IsDaySet(day, week))

   718 						{

   719 						TInt8 weekInt = CalUtils::AgnWeekInMonthToWeekNumberL(week);

   720 						TCalRRule::TDayOfMonth dayOfMonth(day, weekInt);

   721 						dayArray.AppendL(dayOfMonth);

   722 						}

   723 					day = static_cast<TDay>(static_cast<TInt>(day) + 1);

   724 					}

   725 			

   726 				week = static_cast<TAgnRpt::TWeekInMonth>(static_cast<TInt>(week) + 1);

   727 				}

   728 			//coverity [dead_error_begin]

   729 			aRule.SetByDay(dayArray);

   730 

   731 			CleanupStack::PopAndDestroy(&dayArray); // dayArray.Close()

   732 			}

   733 			break;

   734 		case TAgnRpt::EMonthlyByDates:

   735 			{

   736 			aRule.SetType(TCalRRule::EMonthly);

   737 			const TAgnMonthlyByDatesRpt* KMonthlyByDateRpt = static_cast<const TAgnMonthlyByDatesRpt*>(KRpt);

   738 

   739 			RArray<TInt> array;

   740 			CleanupClosePushL(array);

   741 			for (TInt i = 0; i < 31; ++i) // dates run from 0 to 30

   742 				{

   743 				if (KMonthlyByDateRpt->IsDateSet(i))

   744 					{

   745 					array.AppendL(i);

   746 					}

   747 				}

   748 			aRule.SetByMonthDay(array);

   749 			CleanupStack::PopAndDestroy(&array);

   750 			}

   751 			break;

   752 		default:

   753 			CalUtils::Panic(EInvalidRepeatRuleType);

   754 			break;

   755 		}

   756 

   757 	return ETrue;

   758 	}

   759 

   760 TBool CCalEntryImpl::CompareL(const CCalEntry& aEntry)

   761 	{

   762 	// load full CAgnEntries before comparison

   763 	LoadFullEntryL();

   764 	aEntry.Impl()->LoadFullEntryL();

   765 	

   766 	// Load both entry's summary, description and alarm action data before comparing - these properties

   767 	// are stored in separate streams so may not be loaded at this point

   768 	SummaryL();

   769 	aEntry.SummaryL();

   770 	DescriptionL();

   771 	aEntry.DescriptionL();

   772 	delete AlarmL();

   773 	delete aEntry.AlarmL();

   774 	

   775 	return (iFullEntry->CompareL(*aEntry.Impl()->GetFullEntryL()));

   776 	}

   777 

   778 void CCalEntryImpl::CopyFromL(CCalEntryImpl& aOther, CCalEntry::TCopyType aCopyType)

   779 	{

   780 	TCalCollectionId collectionId = 0;

   781 	if (iLiteEntry)

   782 		{

   783 		TUint8 collectionId = aOther.SimpleEntry()->CollectionId();

   784 		}

   785 	aOther.LoadFullEntryL();

   786 	// Delete old state.

   787 	ClearSimpleEntry();

   788 

   789 	if(iCalAttendeeList)

   790 		{

   791 		iCalAttendeeList->ResetAndDestroy();

   792 		delete iCalAttendeeList; 	

   793 		iCalAttendeeList = NULL;

   794 		}

   795 

   796 	if(iCalCategoryList)

   797 		{

   798 		iCalCategoryList->ResetAndDestroy();

   799 		delete iCalCategoryList; 

   800 		iCalCategoryList = NULL;

   801 		}

   802 

   803 	delete iCalOrganizer;

   804 	iCalOrganizer = NULL;

   805 

   806 	if(iSessionImpl)

   807 		{

   808         // Use this entry's existing uid.

   809 		iSessionImpl->DecrementReferenceCount();

   810 		}

   811 	iSessionImpl = aOther.iSessionImpl;

   812 	if (iSessionImpl)

   813 		{

   814 		iSessionImpl->IncrementReferenceCount();

   815 		}

   816 

   817 	// ensure other entry has a full CAgnEntry

   818 	aOther.LoadFullEntryL();

   819 	

   820 	// ensure other entry has summary, description and alarm action properties loaded - these

   821 	// are stored in separate streams

   822 	aOther.SummaryL();

   823 	aOther.DescriptionL();

   824 	delete aOther.AlarmL();

   825 	

   826 	iFullEntry->CopyFromL(*aOther.iFullEntry, aCopyType);

   827 	iFullEntry->SetLastModifiedDate();

   828 	iFullEntry->SetCollectionId(collectionId);

   829 	}

   830 

   831 void CCalEntryImpl::SetAlarmL(CCalAlarm* aAlarm)

   832 	{

   833 	LoadFullEntryL();

   834 	

   835 	if ( aAlarm == NULL ) 

   836 		{

   837 		// if aAlarm is NULL, clear the alarm data

   838 		iFullEntry->ClearAlarm();

   839 		}

   840 	else

   841 		{

   842 		// This method does not take ownership of aAlarm, so need to copy the alarm details

   843 		// before adding to the entry.

   844 		

   845 		// the alarm must be on the same day in local time as the event

   846 		TDateTime dt = iFullEntry->EntryTime().LocalL().DateTime();

   847 		TInt minutes = dt.Hour()*60 + dt.Minute();

   848 		__ASSERT_ALWAYS(minutes - aAlarm->TimeOffset().Int() <= KAgnMinutesInADay, User::Leave(KErrNotSupported));

   849 

   850 		iFullEntry->SetAlarmOffset(aAlarm->TimeOffset());

   851 	 	iFullEntry->SetAlarmSoundNameL(aAlarm->AlarmSoundNameL());

   852 

   853 		CCalContent* alarmAction = aAlarm->AlarmAction(); // doesn't take ownership

   854 		

   855 		if ( alarmAction )

   856 			{

   857 			CAgnContent* agnAlarmAction = static_cast<CAgnContent*>(alarmAction->Impl());

   858 			

   859 			if ( agnAlarmAction )

   860 				{

   861 				CAgnContent* alarmActionCopy = agnAlarmAction->CloneL();

   862 				iFullEntry->SetAlarmAction(alarmActionCopy); // entry takes ownership of alarmActionCopy

   863 				}					

   864 			}

   865 		else

   866 		    {

   867 		    iFullEntry->SetAlarmAction(NULL); 

   868 		    }

   869 		}

   870 	}

   871 

   872 CCalAlarm* CCalEntryImpl::AlarmL()

   873 	{

   874 	LoadFullEntryL();

   875 	

   876 	if (!iFullEntry->HasAlarm())

   877 		{

   878 		return NULL;

   879 		}

   880         

   881 	TTime time = iFullEntry->EntryTime().LocalL();

   882 	

   883 	// Invalid or non-existant entries are set on import to NULL time

   884 	// That being the case, we return NULL for the Alarm.

   885 	TDateTime timeOfEvent;

   886 	if(time == Time::NullTTime())

   887 		{

   888 		return NULL;

   889 		}

   890 	else

   891 		{

   892 		timeOfEvent = time.DateTime();

   893 		}

   894 

   895 	CCalAlarm* alarm = CCalAlarm::NewL();

   896 	CleanupStack::PushL(alarm);

   897 	

   898 	alarm->SetTimeOffset(iFullEntry->AlarmOffset().Int());

   899 	alarm->SetAlarmSoundNameL(iFullEntry->AlarmSoundName());

   900 	

   901 	if(!iFullEntry->AlarmActionIsLoaded())

   902 		{

   903 		CAgnContent* agnAlarmaction = iSessionImpl->Server().RestoreAlarmActionL(iFullEntry->AlarmActionStreamId(), iSessionImpl->FileId());

   904 		// Restore should always return something, even if it's only a Null Descriptor

   905 		iFullEntry->SetAlarmAction(agnAlarmaction);

   906 		}

   907 

   908 	if (iFullEntry->AlarmAction())

   909 		{

   910 		CCalContent* alarmAction = CCalContent::NewL();

   911 		CleanupStack::PushL(alarmAction);

   912 		CAgnContent* agnAlarmActionCopy = iFullEntry->AlarmAction()->CloneL();

   913 		alarmAction->SetImpl(agnAlarmActionCopy); // Takes ownership of agnAlarmAction.

   914 		alarm->SetAlarmAction(alarmAction); // Takes ownership of alarmAction.

   915 		CleanupStack::Pop(alarmAction);

   916 		}

   917 

   918 	CleanupStack::Pop(alarm);

   919 	return alarm;

   920 	}

   921 

   922 void CCalEntryImpl::SetCommonRptDataL(const TCalRRule& aRpt, CAgnRptDef& aRptRule)

   923 	{

   924 	// set repeat rule data which is not specific to the rule type

   925 	// Both repeating count and until time could be set. If so, the one come earlist will be set as repeating until time.

   926 	// Note that the repeating until time will be adjusted in TAgnRpt::UntilTimeL() when the entry is stored (CCalEntryViewImpl::DoStore and 

   927 	// CAgnSimpleEntry::AdjustStartUntilTimeForRepEntryL)By then, the TZ rule has been set to a repeating entry.

   928 	aRptRule.SetInterval(aRpt.Interval());

   929 	const_cast<TAgnRpt*> (aRptRule.RRule())->SetCount(aRpt.Count());

   930 

   931     TTime untilTime = aRpt.Until().TimeLocalL();

   932     if (untilTime != Time::NullTTime())

   933     	{

   934 		TAgnCalendarTime untilTimeTAgn = CalUtils::TCalTimeToTAgnCalendarTimeL(aRpt.Until());

   935 		aRptRule.SetUntilTime(untilTimeTAgn);

   936     	}

   937 	}

   938 

   939 void CCalEntryImpl::SetRRuleL(const TCalRRule& aRpt)

   940 	{

   941 	if (aRpt.Until().TimeLocalL() != Time::NullTTime() && aRpt.DtStart().TimeLocalL() >= aRpt.Until().TimeLocalL())

   942 		{

   943 		// if Until time is set to earlier than the start time and is non-NULL, leave

   944 		User::Leave(KErrArgument);

   945 		}

   946 	LoadFullEntryL();

   947 

   948 	//Leaves if this is a todo entry and its end date has not been set or this is a non-todo entry and its start date has not been set

   949 	//since repeating pattern is based on those time attributes.

   950 	if ( ! iFullEntry->EntryTime().IsSet())

   951 		{

   952 		User::Leave(KErrArgument);

   953 		}

   954 

   955 	TBool createdNewRptDef = EFalse;

   956 	CAgnRptDef* rptDef = iFullEntry->RptDef();

   957 	if(rptDef == NULL)

   958 		{

   959 		rptDef = CAgnRptDef::NewL(*iFullEntry);

   960 		CleanupStack::PushL(rptDef);

   961 		createdNewRptDef = ETrue;

   962 		}

   963 

   964 	switch (aRpt.Type())

   965 		{

   966 		case TCalRRule::EDaily:

   967 			{

   968 			TAgnDailyRpt daily(*rptDef);

   969 			rptDef->SetRRuleL(daily);

   970 			}

   971 			break;

   972 		case TCalRRule::EWeekly:

   973 			{

   974 			TAgnWeeklyRpt weekly(*rptDef);

   975 			weekly.SetFirstDayOfWeek(aRpt.WkSt());

   976 			RArray<TDay> array;

   977 			CleanupClosePushL(array);

   978 			aRpt.GetByDayL(array);

   979 			const TInt KWeeklyDayCount = array.Count();

   980 			for (TInt i = 0; i < KWeeklyDayCount; ++i)

   981 				{

   982 				weekly.SetDay(array[i]);

   983 				}

   984 			CleanupStack::PopAndDestroy(&array);

   985 			

   986 			rptDef->SetRRuleL(weekly);

   987 			}

   988 			break;

   989 		case TCalRRule::EMonthly:

   990 			{

   991 			RArray<TInt> array;

   992 			CleanupClosePushL(array);

   993 			aRpt.GetByMonthDayL(array);

   994 			if (array.Count() <= 0)

   995 				{

   996 				// may be monthly by week

   997 				RArray<TCalRRule::TDayOfMonth> dayArray;

   998 				CleanupClosePushL(dayArray);

   999 				aRpt.GetByDayL(dayArray);

  1000 				const TInt KMonthlyDayCount = dayArray.Count();

  1001 				if (KMonthlyDayCount > 0)

  1002 					{

  1003 					TAgnMonthlyByDaysRpt monthlyByDayAndWeek(*rptDef);

  1004 					for (TInt i = 0; i < KMonthlyDayCount; ++i)

  1005 						{

  1006 						TCalRRule::TDayOfMonth dayOfMonth = dayArray[i];

  1007 						TAgnRpt::TWeekInMonth weekNum = CalUtils::WeekNumberToAgnWeekInMonthL(dayOfMonth.WeekInMonth());

  1008 						monthlyByDayAndWeek.SetDay(dayOfMonth.Day(), weekNum);

  1009 						}

  1010 					

  1011 					rptDef->SetRRuleL(monthlyByDayAndWeek);

  1012 					}

  1013 				CleanupStack::PopAndDestroy(&dayArray); // dayArray.Close()

  1014 				}

  1015 			else

  1016 				{

  1017 				TAgnMonthlyByDatesRpt monthlyByDate(*rptDef);

  1018 				const TInt KMonthlyDateCount = array.Count();

  1019 				for (TInt i = 0; i < KMonthlyDateCount; ++i)

  1020 					{

  1021 					monthlyByDate.SetDate(array[i]);

  1022 					}

  1023 				

  1024 				rptDef->SetRRuleL(monthlyByDate);

  1025 				}

  1026 			CleanupStack::PopAndDestroy(&array); // array.Reset();

  1027 			}

  1028 			break;

  1029 		case TCalRRule::EYearly:

  1030 			{

  1031 			RArray<TCalRRule::TDayOfMonth> dayArray;

  1032 			CleanupClosePushL(dayArray);

  1033 			aRpt.GetByDayL(dayArray);

  1034 			if (dayArray.Count() > 0)

  1035 				{

  1036 				RArray<TMonth> monthArray;

  1037 				CleanupClosePushL(monthArray);

  1038 				aRpt.GetByMonthL(monthArray);

  1039 				if (monthArray.Count() > 0)

  1040 					{

  1041 					TDay day = dayArray[0].Day();

  1042 					TAgnRpt::TWeekInMonth week = CalUtils::WeekNumberToAgnWeekInMonthL(dayArray[0].WeekInMonth());

  1043 					TMonth month = monthArray[0];

  1044 

  1045 					TAgnYearlyByDayRpt yearlyByDay(*rptDef);

  1046 

  1047 					// Check that the first month to repeat on is earlier than the repeat dtstart date...

  1048 					TDateTime rptStartTime = aRpt.DtStart().TimeUtcL().DateTime();

  1049 					TInt year = rptStartTime.Year();

  1050 					if (month < rptStartTime.Month())

  1051 						{

  1052 						// ...if not, start the following year

  1053 						year++;

  1054 						}

  1055 						

  1056 					TTime newStartDay = yearlyByDay.FindStartDayL(day, week, month, year);

  1057 					TCalTime newStartDaycal;

  1058 					newStartDaycal.SetTimeLocalL(newStartDay);

  1059 					const_cast<TCalRRule&>(aRpt).SetDtStart(newStartDaycal);

  1060 					TTime untilTimeLocal = yearlyByDay.UntilTimeL().LocalL();

  1061 					TDateTime rptUntilTime = untilTimeLocal.DateTime();

  1062 					if (aRpt.Count() != 0 || year < rptUntilTime.Year() ||

  1063 						(year == rptUntilTime.Year() && month < rptUntilTime.Month())

  1064 						)

  1065 						{

  1066                         // The count has been set

  1067                         // or the first month to repeat on is not later than the repeat until date

  1068 						rptDef->SetRRuleL(yearlyByDay);

  1069 						}

  1070 					}

  1071 				else

  1072 					{

  1073 					User::Leave(KErrArgument);	

  1074 					}	

  1075 				CleanupStack::PopAndDestroy(&monthArray);

  1076 				}

  1077 			else

  1078 				{

  1079 				TAgnYearlyByDateRpt yearlyByDate(*rptDef);

  1080 				rptDef->SetRRuleL(yearlyByDate);

  1081 				}

  1082 			CleanupStack::PopAndDestroy(&dayArray);

  1083 			}

  1084 			break;

  1085 		default:

  1086 			User::Leave(KErrNotSupported);

  1087 			break;

  1088 		}

  1089 	

  1090 	if (rptDef->RRule())

  1091 		{

  1092 		SetCommonRptDataL(aRpt, *rptDef);

  1093 		}

  1094 	

  1095 	if (createdNewRptDef)

  1096 		{

  1097 		if (rptDef->RRule())

  1098 			{

  1099 			iFullEntry->SetRptDefL(*rptDef);

  1100 			}

  1101 		CleanupStack::PopAndDestroy(rptDef);

  1102 		}

  1103 	

  1104 	//Move the entry start date is same as repeating date

  1105 	

  1106 	TDateTime newEntryDateTime;

  1107 	if(EntryTypeL() == CCalEntry::ETodo)

  1108 		{

  1109 		newEntryDateTime = EndTimeL().TimeLocalL().DateTime();	

  1110 		}

  1111 	else

  1112 		{

  1113 		newEntryDateTime = StartTimeL().TimeLocalL().DateTime();		

  1114 		}

  1115 

  1116 	newEntryDateTime.SetYear(aRpt.DtStart().TimeLocalL().DateTime().Year());

  1117 	newEntryDateTime.SetMonth(aRpt.DtStart().TimeLocalL().DateTime().Month());

  1118 	newEntryDateTime.SetDay(aRpt.DtStart().TimeLocalL().DateTime().Day());

  1119 	

  1120 	//adjust the entrytime (it the entry start time for non-todos and end time for todos) 

  1121 	iFullEntry->MoveStartTimeLocalL(newEntryDateTime);

  1122 	}

  1123 

  1124 void CCalEntryImpl::ClearRepeatingPropertiesL()

  1125 	{

  1126 	SimpleEntry()->ClearRepeat();

  1127 	}

  1128 

  1129 TCalTime CCalEntryImpl::NextInstanceForLocalUIDL(const TCalTime& aTime)

  1130 	{

  1131 	const TTime KTimeUtc = aTime.TimeUtcL() + TTimeIntervalMicroSeconds(1);

  1132 	TTime nextTimeUtc = Time::NullTTime();

  1133 	

  1134 	const CAgnRptDef* KRptDef = SimpleEntry()->RptDef();