1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 #include "engine.h"

    20 #include "enginewrapper.h"

    21 

    22 #include "creator_calendar.h" 

    23 #include "creator_traces.h"

    24 #include "creator_scriptentry.h"

    25 #include <e32base.h>

    26 #include <e32math.h>

    27 #include <calrrule.h> 

    28 #include <calalarm.h>

    29 

    30 static const TInt KCalendarFieldLength = 128;

    31 

    32 

    33 CCreatorCalenderAttendee::CCreatorCalenderAttendee() 

    34     {}

    35 

    36 CCreatorCalenderAttendee::~CCreatorCalenderAttendee()

    37     {

    38     delete iCommonName;

    39     delete iEmailAddress;

    40     }

    41 

    42 CCreatorCalenderAttendee* CCreatorCalenderAttendee::NewL()

    43     {

    44     CCreatorCalenderAttendee* self = new (ELeave) CCreatorCalenderAttendee;

    45     return self;

    46     }

    47 

    48 void CCreatorCalenderAttendee::SetCommonNameL(const TDesC& aName)

    49     {

    50     delete iCommonName;

    51     iCommonName = 0;

    52     iCommonName = HBufC::NewL(aName.Length());

    53     iCommonName->Des().Copy(aName);

    54     }

    55 

    56 void CCreatorCalenderAttendee::SetEmailAddressL(const TDesC& aEmail)

    57     {

    58     delete iEmailAddress;

    59     iEmailAddress = 0;

    60     iEmailAddress = HBufC::NewL(aEmail.Length());

    61     iEmailAddress->Des().Copy(aEmail);

    62     }

    63 

    64 void CCreatorCalenderAttendee::SetRole(CCalAttendee::TCalRole aRole)

    65     {

    66     iRole = aRole;

    67     }

    68 

    69 void CCreatorCalenderAttendee::SetStatus(CCalAttendee::TCalStatus aStatus)

    70     {

    71     iStatus = aStatus;

    72     }

    73 

    74 const TDesC& CCreatorCalenderAttendee::CommonName() const

    75     {

    76     if( iCommonName == 0 )

    77     	return iDummy;

    78     return *iCommonName;

    79     }

    80 

    81 const TDesC& CCreatorCalenderAttendee::EmailAddress() const

    82     {

    83     if( iEmailAddress == 0 )

    84     	return iDummy;

    85     

    86     return *iEmailAddress;

    87     }

    88 

    89 CCalAttendee::TCalRole CCreatorCalenderAttendee::Role() const

    90     {

    91     return iRole;

    92     }

    93 

    94 CCalAttendee::TCalStatus CCreatorCalenderAttendee::Status() const

    95     {

    96     return iStatus;

    97     }

    98 

    99 TBool CCalenderInterimParameters::IsAllowedEntryStatus(CCalEntry::TType aType, CCalEntry::TStatus aStatus)

   100     {

   101     if( aType == CCalEntry::ETodo )

   102         {

   103         return  aStatus == CCalEntry::ECancelled ||

   104                 aStatus == CCalEntry::ETodoNeedsAction ||

   105                 aStatus == CCalEntry::ETodoCompleted ||

   106                 aStatus == CCalEntry::ETodoInProcess;

   107         }

   108     

   109     return  aStatus == CCalEntry::ETentative ||

   110             aStatus == CCalEntry::EConfirmed ||

   111             aStatus == CCalEntry::ECancelled;

   112     }

   113 

   114 //----------------------------------------------------------------------------

   115 

   116 CCalenderInterimParameters::CCalenderInterimParameters ( )

   117     {

   118     LOGSTRING("Creator: CCalenderInterimParameters::CCalenderInterimParameters");

   119 

   120     iAppointmentLocation = HBufC::New (KCalendarFieldLength );

   121     iAppointmentReason = HBufC::New (KCalendarFieldLength );

   122     iEventReason = HBufC::New (KCalendarFieldLength );

   123     iAnniversaryReason = HBufC::New (KCalendarFieldLength );

   124     iTodoTask = HBufC::New (KCalendarFieldLength );

   125     iReminderReason = HBufC::New (KCalendarFieldLength );

   126     iDescription = HBufC::New (KCalendarFieldLength );

   127     iSummary = HBufC::New (KCalendarFieldLength );

   128     iLocation = HBufC::New (KCalendarFieldLength );

   129     iOrganizerName = HBufC::New (KCalendarFieldLength );

   130     iOrganizerEmail = HBufC::New (KCalendarFieldLength );

   131 

   132     // set defaults, start date today and end date = today + 1 month

   133     iRandomModeStartTime.HomeTime ( );

   134     iRandomModeEndTime = iRandomModeStartTime;

   135     iRandomModeEndTime += TTimeIntervalMonths (1 );

   136     iAlarmTime = Time::NullTTime();

   137     iUseRandomAlarmTime = EFalse;

   138     iStatus = CCalEntry::ENullStatus;

   139     }

   140 

   141 CCalenderInterimParameters::~CCalenderInterimParameters ( )

   142     {

   143     LOGSTRING("Creator: CCalenderInterimParameters::~CCalenderInterimParameters");

   144 

   145     delete iTodoTask;

   146     delete iAnniversaryReason;

   147     delete iEventReason;

   148     delete iAppointmentReason;

   149     delete iAppointmentLocation;

   150     delete iReminderReason;

   151     delete iDescription;

   152     delete iSummary;

   153     delete iLocation;

   154     delete iOrganizerName;

   155     delete iOrganizerEmail;

   156     iAttendees.ResetAndDestroy();

   157     iAttendees.Close();

   158     iAttendeeLinkIds.Reset();

   159     iAttendeeLinkIds.Close();

   160     }

   161 

   162 void CCalenderInterimParameters::ParseL (CCommandParser* parser,

   163         TParseParams aCase )

   164     {

   165     LOGSTRING("Creator: CCalenderInterimParameters::ParseL");

   166 

   167     HBufC* tempBuf= NULL;

   168 

   169     switch (aCase )

   170         {

   171 

   172         case MCreatorModuleBaseParameters::ECalendarTodo:

   173             {

   174 

   175             parser->StrParserL (tempBuf, '|' );

   176 

   177             CleanupStack::PushL (tempBuf );

   178 

   179             this->iTodoDueTime = TTime (tempBuf->Des ( ) );

   180 

   181             parser->StrParserL (this->iTodoTask, '|' );

   182 

   183             parser->StrParserL (tempBuf, ';' );

   184             this->iTodoPriority = 2;

   185             if (tempBuf->Compare (_L("LOW") ) == 0 )

   186                 this->iTodoPriority = 3;

   187             else

   188                 if (tempBuf->Compare (_L("HIGH") ) == 0 )

   189                     this->iTodoPriority = 1;

   190 

   191             CleanupStack::PopAndDestroy (tempBuf );

   192 

   193             }

   194 

   195         case MCreatorModuleBaseParameters::ECalendarMemo:

   196             {

   197 

   198             parser->StrParserL (tempBuf, '|' );

   199 

   200             this->iStartTime = TTime (tempBuf->Des ( ) );

   201 

   202             parser->StrParserL (tempBuf, '|' );

   203             this->iEndTime = TTime (tempBuf->Des ( ) );

   204 

   205             parser->StrParserL (this->iDescription, ';' );

   206 

   207             CleanupStack::PopAndDestroy (tempBuf );

   208             }

   209 

   210         case MCreatorModuleBaseParameters::ECalendarMeeting:

   211             {

   212 

   213             parser->StrParserL (tempBuf, '|' );

   214 

   215             CleanupStack::PushL (tempBuf );

   216 

   217             this->iStartTime = TTime (tempBuf->Des ( ) );

   218 

   219             parser->StrParserL (tempBuf, '|' );

   220             this->iEndTime = TTime (tempBuf->Des ( ) );

   221 

   222             parser->StrParserL (this->iLocation, '|' );

   223             parser->StrParserL (this->iDescription, ';' );

   224 

   225             CleanupStack::PopAndDestroy (tempBuf );

   226             }

   227 

   228         case MCreatorModuleBaseParameters::ECalendarAnniv:

   229             {

   230 

   231             parser->StrParserL (tempBuf, '|' );

   232 

   233             CleanupStack::PushL (tempBuf );

   234 

   235             this->iStartTime = TTime (tempBuf->Des ( ) );

   236 

   237             parser->StrParserL (this->iDescription, ';' );

   238 

   239             CleanupStack::PopAndDestroy (tempBuf );

   240 

   241             }

   242         default:

   243             {

   244             //implement 

   245             }

   246         }

   247     }

   248 //----------------------------------------------------------------------------

   249 

   250 CCreatorInterimCalendar* CCreatorInterimCalendar::NewL (CCreatorEngine* aEngine )

   251     {

   252     CCreatorInterimCalendar* self = CCreatorInterimCalendar::NewLC (aEngine );

   253     CleanupStack::Pop (self );

   254     return self;

   255     }

   256 

   257 CCreatorInterimCalendar* CCreatorInterimCalendar::NewLC (CCreatorEngine* aEngine )

   258     {

   259     CCreatorInterimCalendar* self = new (ELeave) CCreatorInterimCalendar;

   260     CleanupStack::PushL (self );

   261     self->ConstructL (aEngine );

   262     return self;

   263     }

   264 

   265 CCreatorInterimCalendar::CCreatorInterimCalendar ( )

   266     {

   267     }

   268 

   269 void CCreatorInterimCalendar::ConstructL (CCreatorEngine* aEngine )

   270     {

   271     LOGSTRING("Creator: CCreatorInterimCalendar::ConstructL");

   272 

   273     iEngine = aEngine;

   274 

   275     // set defaults, start date today and end date = today + 1 month

   276     iRandomModeStartTime.HomeTime ( );

   277     iRandomModeEndTime = iRandomModeStartTime;

   278     iRandomModeEndTime += TTimeIntervalMonths (1 );

   279 

   280     iCalSession = CCalSession::NewL ( );

   281     // Create and open a calendar file

   282     const TDesC& fileName = iCalSession->DefaultFileNameL ( );//default filename is: "C:Calendar"

   283     TRAPD(err, iCalSession->CreateCalFileL(fileName))

   284     ;

   285     // ignore KErrAlreadyExists leave code

   286     if (err != KErrAlreadyExists )

   287         {

   288         User::LeaveIfError (err );

   289         }

   290     // Open the calendar file

   291     iCalSession->OpenL (fileName );

   292     iCalEntryView = CCalEntryView::NewL (*iCalSession, *this );

   293     iNumberRepeatingEntries = 0;

   294     iNumberOfAttendees = 0; //iEngine->RandomNumber(2, 15);

   295     iSetAlarm = EFalse;

   296     iWaiter = CAsyncWaiter::NewL();

   297     }

   298 

   299 CCreatorInterimCalendar::~CCreatorInterimCalendar ( )

   300     {

   301     LOGSTRING("Creator: CCreatorInterimCalendar::~CCreatorInterimCalendar");

   302 

   303     if ( iEngine && iEntryIds.Count() )

   304         {

   305         TRAP_IGNORE( iEngine->WriteEntryIdsToStoreL( iEntryIds, KUidDictionaryUidCalendar ) );

   306         }

   307         

   308     iEntryIds.Reset();

   309     iEntryIds.Close();

   310         

   311     if (iParameters )

   312         {

   313         delete iParameters;

   314         }

   315 

   316     if (iCalEntryView )

   317         {

   318         delete iCalEntryView;

   319         }

   320 

   321     if (iCalSession )

   322         {

   323         delete iCalSession;

   324         }

   325     delete iSoundFileArray;

   326     delete iWaiter;

   327     delete iTmpCN;

   328     delete iTmpEmail;

   329     }

   330 

   331 //----------------------------------------------------------------------------

   332 

   333 void CCreatorInterimCalendar::QueryDialogClosedL(TBool aPositiveAction, TInt aUserData)

   334     {

   335     LOGSTRING("Creator: CCreatorInterimCalendar::QueryDialogClosedL");

   336     

   337     if( aPositiveAction == EFalse && aUserData != ECreatorCalendarAddDefaultAlarm )

   338         {

   339         iEngine->ShutDownEnginesL();

   340         return;

   341         }

   342     

   343     const TDesC* showText = &KSavingText;

   344     TBool finished(EFalse);

   345     TBool retval(ETrue);

   346     switch(aUserData)

   347         {

   348         case ECreatorCalendarDelete:

   349             iEntriesToBeCreated = 1;

   350             showText = &KDeletingText;

   351             finished = ETrue;

   352             break;

   353         case ECreatorCalendarStart:

   354             if( iCommand == ECmdCreateCalendarEntryEvents || iCommand == ECmdCreateCalendarEntryAppointments )

   355                 {

   356                 _LIT(KRepeatingNum, "How many repeating (weekly) entries");

   357                 retval = iEngine->GetEngineWrapper()->EntriesQueryDialog(&iNumberRepeatingEntries, KRepeatingNum, ETrue, this, ECreatorCalendarGetWeeklyEntries);

   358                 }

   359             else

   360                 {

   361                 _LIT(KStartPeriodDate, "Start date of creation period");// \n dd/mm/yyyy

   362                 retval = iEngine->GetEngineWrapper()->TimeQueryDialog(&iRandomModeStartTime, KStartPeriodDate, this, ECreatorCalendarGetStartDate); // ask start date

   363                 }

   364             break;

   365         case ECreatorCalendarGetWeeklyEntries:

   366             _LIT(KAttendeesNum, "How many attendees to create");

   367             retval = iEngine->GetEngineWrapper()->EntriesQueryDialog(&iNumberOfAttendees, KAttendeesNum, ETrue, this, ECreatorCalendarGetAttendies);

   368             break;

   369         case ECreatorCalendarGetAttendies:

   370             {

   371             // ask start date

   372             _LIT(KStartPeriodDate, "Start date of creation period");

   373             retval = iEngine->GetEngineWrapper()->TimeQueryDialog(&iRandomModeStartTime, KStartPeriodDate, this, ECreatorCalendarGetStartDate ); 

   374             }

   375             break;

   376         case ECreatorCalendarGetStartDate:

   377             {

   378             _LIT(KEndPeriodDate, "End date of creation period\n dd/mm/yyyy");

   379             iEngine->GetEngineWrapper()->TimeQueryDialog (&iRandomModeEndTime, KEndPeriodDate, this, ECreatorCalendarGetEndDate ); // ask end date

   380             }

   381             break;

   382         case ECreatorCalendarGetEndDate:

   383            if (iRandomModeStartTime > iRandomModeEndTime ) // check end date is ok

   384                 {

   385                 iEngine->GetEngineWrapper()->ShowNote(_L("End date must be after start date") );

   386                 retval = EFalse;

   387                 }

   388             else 

   389                 {

   390                 retval = iEngine->GetEngineWrapper()->YesNoQueryDialog(_L("Add default alarm?"), this, ECreatorCalendarAddDefaultAlarm);

   391                 }

   392            break;

   393         case ECreatorCalendarAddDefaultAlarm:

   394             iSetAlarm = aPositiveAction;

   395             finished = ETrue;

   396             break;

   397         default:

   398             //some error

   399             retval = EFalse;

   400             break;

   401         }

   402     if( retval == EFalse )

   403         {

   404         iEngine->ShutDownEnginesL();

   405         }

   406     else if( finished )

   407         {

   408         // add this command to command array

   409         iEngine->AppendToCommandArrayL(iCommand, NULL, iEntriesToBeCreated);

   410         // started exucuting commands

   411         iEngine->ExecuteFirstCommandL( *showText );

   412         }

   413     }

   414 

   415 //----------------------------------------------------------------------------

   416 

   417 TBool CCreatorInterimCalendar::AskDataFromUserL( TInt aCommand )

   418     {

   419     LOGSTRING("Creator: CCreatorInterimCalendar::AskDataFromUserL");

   420     

   421     CCreatorModuleBase::AskDataFromUserL( aCommand );//ignore retval

   422     

   423     if( aCommand == ECmdDeleteCalendarEntries )

   424         {

   425         return iEngine->GetEngineWrapper()->YesNoQueryDialog(_L("Delete all calendar entries?"), this, ECreatorCalendarDelete );

   426         }

   427     if( aCommand == ECmdDeleteCreatorCalendarEntries )

   428         {

   429         return iEngine->GetEngineWrapper()->YesNoQueryDialog(_L("Delete all calendar entries created with Creator?"), this, ECreatorCalendarDelete ); 

   430         }

   431 

   432     // display queries

   433     return iEngine->GetEngineWrapper()->EntriesQueryDialog(&iEntriesToBeCreated, _L("How many entries to create?"), EFalse, this, ECreatorCalendarStart ); // ask number of entries to create

   434     }

   435 

   436 //----------------------------------------------------------------------------

   437 

   438 TInt CCreatorInterimCalendar::CreateAppointmentEntryL (

   439         CCreatorModuleBaseParameters *aParameters )

   440     {

   441     LOGSTRING("Creator: CCreatorInterimCalendar::CreateAppointmentEntryL");

   442         

   443     delete iParameters;

   444     iParameters = 0;

   445     

   446     CCalenderInterimParameters* parameters = (CCalenderInterimParameters*)aParameters;   

   447     

   448     if( !parameters )

   449         {

   450         iParameters = new(ELeave) CCalenderInterimParameters;

   451         parameters = iParameters;  

   452         parameters->iRandomModeStartTime = iRandomModeStartTime;

   453         parameters->iRandomModeEndTime = iRandomModeEndTime;    

   454     

   455         // difference between start and end times

   456         TTimeIntervalMinutes differenceInMinutes;

   457         parameters->iRandomModeEndTime.MinutesFrom (

   458                 parameters->iRandomModeStartTime, differenceInMinutes );

   459 

   460         // start time (= something between the period start and end date)        

   461         parameters->iStartTime = parameters->iRandomModeStartTime;

   462         parameters->iStartTime

   463                 += TTimeIntervalMinutes (iEngine->RandomNumber (differenceInMinutes.Int ( ) ) );   

   464         // set end time (= start time + some random time)    

   465         parameters->iEndTime = parameters->iStartTime;    

   466         parameters->iEndTime

   467                 += TTimeIntervalMinutes (iEngine->RandomNumber (5, 500 ) );

   468         

   469 

   470         // strings        

   471         parameters->iLocation->Des ( )

   472                 = iEngine->RandomString (CCreatorEngine::EMeetingPlace );

   473         parameters->iDescription->Des ( )

   474                 = iEngine->RandomString (CCreatorEngine::EMeetingReason );

   475         

   476         parameters->iSummary->Des()

   477                         = parameters->iDescription->Des();

   478         

   479         parameters->iNumberRepeatingEntries = iNumberRepeatingEntries;

   480         parameters->iNumberOfAttendees = iNumberOfAttendees;

   481         }

   482 

   483     TInt err = KErrNone;

   484     HBufC8* guid = HBufC8::NewLC (255 );

   485     TPtr8 uidP=guid->Des ( );

   486     GenerateRandomId (uidP );

   487     CCalEntry* entry = CCalEntry::NewL (CCalEntry::EAppt, guid,

   488             CCalEntry::EMethodAdd, 0 );

   489     CleanupStack::PushL (entry );

   490 

   491     //Using same text as description and summary	

   492     entry->SetDescriptionL (parameters->iDescription->Des ( ) );

   493     entry->SetSummaryL (parameters->iSummary->Des ( ) );

   494     entry->SetLocationL (parameters->iLocation->Des ( ) );

   495 

   496     TCalTime startTime;

   497     TCalTime endTime;

   498     // Set the start and end times using time values local to the current system time zone

   499     TInt month = (TInt) parameters->iStartTime.DateTime().Month();

   500     TInt date = parameters->iStartTime.DateTime().Day();

   501     startTime.SetTimeLocalL (parameters->iStartTime );

   502     endTime.SetTimeLocalL (parameters->iEndTime );

   503     entry->SetStartAndEndTimeL (startTime, endTime );       

   504     

   505     if( parameters->IsAllowedEntryStatus(CCalEntry::EAppt, parameters->iStatus))

   506         {

   507         LOGSTRING2("Creator: CCreatorInterimCalendar::CreateAppointmentEntryL setting entry status: %d", parameters->iStatus);

   508         entry->SetStatusL(parameters->iStatus);

   509         }

   510     

   511     // Repeating times:

   512     AddRepeatingRuleL(startTime, *entry, parameters);

   513     SetOrganizerL(*entry, parameters);

   514     

   515     // Alarm:    

   516     if( iSetAlarm || parameters->iUseRandomAlarmTime )

   517         {        

   518         SetRandomAlarmL(*entry);

   519         }

   520     else

   521         {

   522         SetAlarmL(*entry, parameters);

   523         }

   524         

   525     // Add attendees:

   526     AddAttendeesL(*entry, parameters);

   527     

   528     RPointerArray<CCalEntry> array;

   529     CleanupClosePushL (array );

   530     array.AppendL (entry );

   531     

   532     TInt success(0);

   533     //If StoreL() leaves, 'success' contains the number of entries that were stored before it failed

   534     iCalEntryView->StoreL (array, success );

   535 

   536     // id has been generated, store it for being able to delete

   537     // entries created only with Creator

   538     iEntryIds.Append( entry->LocalUidL() );

   539     

   540     //One item should be added at time

   541     if (success != 1 )

   542         {

   543         err = 1;

   544         }

   545 

   546     CleanupStack::PopAndDestroy (&array );

   547     CleanupStack::PopAndDestroy (entry );

   548     CleanupStack::Pop (guid );//guid has been destroyed by entry, which has ownership to guid

   549 

   550     return err;

   551     }

   552 

   553 void CCreatorInterimCalendar::SetOrganizerL(CCalEntry& aCalEntry, CCalenderInterimParameters* parameters )

   554     {    

   555     HBufC* orgName = 0;

   556     HBufC* orgEmail = 0;

   557     _LIT(KSpace, " ");

   558     

   559     //

   560     // Common name

   561     //

   562     if( parameters == 0 || 

   563         parameters->iOrganizerName == 0 || 

   564         parameters->iOrganizerName->Length() == 0 )

   565         {     

   566         // Random:

   567         TPtrC firstname  = iEngine->RandomString(CCreatorEngine::EFirstName);

   568         TPtrC lastname = iEngine->RandomString(CCreatorEngine::ESurname);

   569         orgName = HBufC::NewL(firstname.Length() + lastname.Length() + 1 );

   570         CleanupStack::PushL(orgName);

   571         orgName->Des().Copy(firstname);

   572         orgName->Des().Append(KSpace);

   573         orgName->Des().Append(lastname);        

   574         }

   575     else

   576         {

   577         orgName = HBufC::NewL(parameters->iOrganizerName->Length());

   578         CleanupStack::PushL(orgName);

   579         orgName->Des().Copy(parameters->iOrganizerName->Des());

   580         }

   581     

   582     //

   583     // Email

   584     //

   585     if( parameters == 0 ||

   586         parameters->iOrganizerEmail == 0 || 

   587         parameters->iOrganizerEmail->Length() == 0 )

   588         {        

   589         // Random:

   590         TDesC* tmp = iEngine->CreateEmailAddressLC();

   591         orgEmail = HBufC::NewL(tmp->Length());

   592         orgEmail->Des().Copy(*tmp);

   593         CleanupStack::PopAndDestroy(); // tmp

   594         CleanupStack::PushL(orgEmail);

   595         }

   596     else

   597         {

   598         orgEmail = HBufC::NewL(parameters->iOrganizerEmail->Length());

   599         CleanupStack::PushL(orgEmail);

   600         orgEmail->Des().Copy(parameters->iOrganizerEmail->Des());

   601         }

   602     

   603     SetOrganizerL(aCalEntry, orgName->Des(), orgEmail->Des(), orgEmail->Des());

   604     CleanupStack::PopAndDestroy(); // orgName

   605     CleanupStack::PopAndDestroy(); // orgEmail

   606     }

   607 

   608 void CCreatorInterimCalendar::AddRepeatingRuleL(const TCalTime& aStartTime, CCalEntry& aCalEntry, CCalenderInterimParameters* parameters )

   609     {

   610     RArray<TDay> days;

   611     CleanupClosePushL(days);

   612     

   613     // Recurrence rule. Weekly event.

   614     if( parameters->iNumberRepeatingEntries > 0 )

   615         {

   616         TCalRRule calRepeat(TCalRRule::EWeekly);   

   617         calRepeat.SetDtStart(aStartTime);

   618         calRepeat.SetCount(parameters->iNumberRepeatingEntries);        

   619         calRepeat.SetInterval(1);

   620         //days.AppendL((TDay) iEngine->RandomNumber((TInt)EMonday, (TInt) ESunday));

   621         TDay tempDay(aStartTime.TimeLocalL().DayNoInWeek());

   622         days.AppendL(tempDay);

   623         calRepeat.SetByDay(days);        

   624         aCalEntry.SetRRuleL(calRepeat);

   625         }

   626     else if(parameters->iRecurrentFrequency > TCalRRule::EInvalid)

   627         {

   628         TCalTime calTime;        

   629         // Recurrent frequency

   630         TCalRRule calRepeat(parameters->iRecurrentFrequency);

   631         // Recurrent start        

   632         calRepeat.SetDtStart(aStartTime);

   633         if( parameters->iRecurrentFrequency == TCalRRule::EWeekly )

   634         	{

   635         	TDay tempDay(aStartTime.TimeLocalL().DayNoInWeek());

   636         	days.AppendL(tempDay);        

   637         	calRepeat.SetByDay(days);  

   638         	}

   639         else if( parameters->iRecurrentFrequency == TCalRRule::EMonthly )

   640         	{

   641         	RArray< TInt > daysInMonth;

   642         	CleanupClosePushL(daysInMonth);

   643         	daysInMonth.AppendL(aStartTime.TimeLocalL().DayNoInMonth());

   644         	calRepeat.SetByMonthDay(daysInMonth);

   645         	CleanupStack::PopAndDestroy(&daysInMonth);

   646         	}

   647         else if( parameters->iRecurrentFrequency == TCalRRule::EYearly)

   648         	{

   649         	RArray< TMonth > monthsInYear;

   650         	CleanupClosePushL(monthsInYear);

   651         	monthsInYear.AppendL(aStartTime.TimeLocalL().DateTime().Month());

   652         	calRepeat.SetByMonth(monthsInYear);

   653         	CleanupStack::PopAndDestroy(&monthsInYear);

   654         	}

   655         

   656         // Recurrent interval

   657         if( parameters->iRecurrentInterval > 0 )

   658         	calRepeat.SetInterval(parameters->iRecurrentInterval);

   659                 

   660         // Recurrent end. End can be given as a number of repeating entries or as an end date.

   661         // End date must be later than the start date, otherwise CCalEntry::SetRRuleL() panics.

   662         if( parameters->iRepeatingCount > 0 )

   663             {

   664             calRepeat.SetCount(parameters->iRepeatingCount);

   665             aCalEntry.SetRRuleL(calRepeat);            

   666             }

   667         else

   668             {

   669             TCalTime endTime;

   670             endTime.SetTimeLocalL(parameters->iRecurrentEndTime);

   671             if( endTime.TimeLocalL() > aStartTime.TimeLocalL())

   672             	{

   673             	calRepeat.SetUntil(endTime);

   674             	aCalEntry.SetRRuleL(calRepeat);

   675             	}

   676             }           

   677         }

   678     CleanupStack::PopAndDestroy(&days);

   679     }

   680 

   681 void CCreatorInterimCalendar::SetAlarmL(CCalEntry& aCalEntry, CCalenderInterimParameters* params)

   682     {

   683     if( params->iAlarmTime != Time::NullTTime() )

   684         {

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

   686         CleanupStack::PushL(alarm);

   687         //if( params->iAlarmTime <= params->iStartTime )

   688         //	{

   689         	TTimeIntervalMinutes diff;

   690         	TInt err = params->iStartTime.MinutesFrom(params->iAlarmTime, diff);

   691         	if( err == KErrNone)

   692         		{

   693         		alarm->SetTimeOffset(diff);

   694         		TRAP(err, aCalEntry.SetAlarmL(alarm));

   695         		if( err != KErrNone && err !=  KErrNotSupported )

   696         			{

   697         			User::Leave(err);

   698         			}        		

   699         		}

   700         //	}

   701         CleanupStack::PopAndDestroy(alarm);

   702         }

   703     }

   704 

   705 void CCreatorInterimCalendar::SetRandomAlarmL(CCalEntry& aCalEntry)

   706     {

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

   708     CleanupStack::PushL(alarm);

   709     alarm->SetTimeOffset(TTimeIntervalMinutes(iEngine->RandomNumber(0, 60)));

   710     

   711     TRAPD(err, aCalEntry.SetAlarmL(alarm));

   712     if( err != KErrNone && err !=  KErrNotSupported )

   713     	{

   714     	User::Leave(err);

   715     	}

   716     CleanupStack::PopAndDestroy(alarm);

   717     }

   718 

   719 void CCreatorInterimCalendar::SetPhoneOwnerL(CCalEntry& aCalEntry, const TDesC& aCN, const TDesC& aEmail, const TDesC& aSentBy )

   720     {

   721     CCalUser* phOwner = CCalUser::NewL(aEmail, aSentBy);

   722     CleanupStack::PushL(phOwner);

   723     TRAPD(err, aCalEntry.SetPhoneOwnerL(phOwner));            

   724     CleanupStack::Pop(phOwner);

   725     if( err == KErrNone )

   726         {

   727         phOwner->SetCommonNameL(aCN);

   728         }

   729     else

   730         {

   731         delete phOwner;

   732         }

   733     }

   734 

   735 void CCreatorInterimCalendar::SetOrganizerL(CCalEntry& aCalEntry, const TDesC& aCN, const TDesC& aEmail, const TDesC& aSentBy)

   736     {

   737     CCalUser* organizer = CCalUser::NewL(aEmail, aSentBy);

   738     CleanupStack::PushL(organizer);

   739     TRAPD(err, aCalEntry.SetOrganizerL(organizer));

   740     CleanupStack::Pop(organizer);

   741     if( err == KErrNone )

   742         {

   743         organizer->SetCommonNameL(aCN);

   744         }

   745     else

   746         {

   747         delete organizer;

   748         }

   749     }

   750 

   751 void CCreatorInterimCalendar::AddAttendeesL(CCalEntry& aCalEntry, CCalenderInterimParameters* parameters )

   752     {

   753     if( !parameters )

   754         return;

   755             

   756     // Random attendees:

   757     TInt numOfAttendees = parameters->iNumberOfAttendees;

   758     for( TInt i = 0; i < numOfAttendees; ++i )

   759         {

   760         TPtrC firstname  = iEngine->RandomString(CCreatorEngine::EFirstName);

   761         TPtrC lastname   = iEngine->RandomString(CCreatorEngine::ESurname);

   762         TPtrC company    = iEngine->RandomString(CCreatorEngine::ECompany);

   763         _LIT(KCountry, "com");        

   764         TDesC* emailAddr = iEngine->CreateEmailAddressLC(firstname, lastname, company, KCountry);        

   765         CCalAttendee* attendee = CCalAttendee::NewL(*emailAddr);        

   766         CleanupStack::PushL(attendee);

   767         aCalEntry.AddAttendeeL(attendee);

   768         CleanupStack::Pop(attendee);

   769         attendee->SetCommonNameL(firstname);

   770                 

   771         // Set phone owner:

   772         if( i == 1 )

   773             {             

   774             SetPhoneOwnerL(aCalEntry, firstname, *emailAddr, *emailAddr); 

   775             attendee->SetRoleL(CCalAttendee::EReqParticipant); 

   776             }

   777         // Set organizer:

   778         else if ( i == 0 )

   779             {            

   780             // Organizer is the chairman of the meeting:

   781             SetOrganizerL(aCalEntry, firstname, *emailAddr, *emailAddr);

   782             attendee->SetRoleL(CCalAttendee::EChair);

   783             }

   784         else if( i % 3 == 0 )

   785             {

   786             // every third attendee is optional:

   787             attendee->SetRoleL(CCalAttendee::EOptParticipant);

   788             }

   789         else

   790             {

   791             // Others are required attendees:

   792             attendee->SetRoleL(CCalAttendee::EReqParticipant);            

   793             }

   794         

   795         TInt attStatus = iEngine->RandomNumber(0,5);

   796         attendee->SetStatusL((CCalAttendee::TCalStatus) attStatus);

   797         

   798         CleanupStack::PopAndDestroy(emailAddr);

   799         }

   800     

   801     // Explicit attendees:

   802     for( TInt i = 0; i < parameters->iAttendees.Count(); ++i )

   803         {

   804         CCreatorCalenderAttendee* attendeeInfo = parameters->iAttendees[i];

   805         if( attendeeInfo && attendeeInfo->EmailAddress().Length() > 0)

   806         	{

   807         	CCalAttendee* attendee = CCalAttendee::NewL(attendeeInfo->EmailAddress());

   808         	CleanupStack::PushL(attendee);

   809         	if( attendeeInfo->CommonName().Length() > 0 )

   810         		attendee->SetCommonNameL(attendeeInfo->CommonName());

   811         	attendee->SetRoleL(attendeeInfo->Role());

   812         	attendee->SetStatusL(attendeeInfo->Status());

   813         	attendee->SetResponseRequested(ETrue);

   814         	aCalEntry.AddAttendeeL(attendee);

   815         	CleanupStack::Pop(); // attendee

   816         	}

   817         }

   818     }

   819 //----------------------------------------------------------------------------

   820 

   821 TInt CCreatorInterimCalendar::CreateEventEntryL (

   822         CCreatorModuleBaseParameters *aParameters )

   823     {

   824     LOGSTRING("Creator: CCreatorInterimCalendar::CreateEventEntryL");

   825 

   826     delete iParameters;

   827     iParameters = 0;

   828         

   829     CCalenderInterimParameters* parameters = (CCalenderInterimParameters*)aParameters;       

   830     

   831     // random data needed if no predefined data available

   832     if (!parameters )

   833         {

   834         iParameters = new(ELeave) CCalenderInterimParameters;

   835 

   836         iParameters->iRandomModeStartTime = iRandomModeStartTime;

   837         iParameters->iRandomModeEndTime = iRandomModeEndTime;

   838         iParameters->iNumberRepeatingEntries = iNumberRepeatingEntries;

   839         iParameters->iNumberOfAttendees = iNumberOfAttendees;

   840         

   841         // difference between start and end times

   842         TTimeIntervalMinutes differenceInMinutes;

   843         iParameters->iRandomModeEndTime.MinutesFrom (

   844                 iParameters->iRandomModeStartTime, differenceInMinutes );

   845 

   846         // start time (= something between the period start and end date)

   847         iParameters->iStartTime = iParameters->iRandomModeStartTime;

   848         iParameters->iStartTime

   849                 += TTimeIntervalMinutes (iEngine->RandomNumber (differenceInMinutes.Int ( ) ) );

   850 

   851         // set end time (= start time + some random time)

   852         iParameters->iEndTime = iParameters->iStartTime;

   853         iParameters->iEndTime

   854                 += TTimeIntervalMinutes (iEngine->RandomNumber (5, 500 ) );        

   855 

   856         // strings

   857         iParameters->iDescription->Des()

   858                 = iEngine->RandomString (CCreatorEngine::EMemoText );

   859         

   860         iParameters->iSummary->Des() = iParameters->iDescription->Des();

   861         

   862         // Random event status:

   863         iParameters->iStatus = 

   864             (CCalEntry::TStatus) iEngine->RandomNumber(0, (TInt) CCalEntry::ECancelled);

   865         

   866         parameters = iParameters;

   867         }

   868 

   869     TInt err = KErrNone;

   870     HBufC8* guid = HBufC8::NewLC (255 );

   871     TPtr8 uidP=guid->Des ( );

   872     GenerateRandomId (uidP );

   873     CCalEntry* entry = CCalEntry::NewL (CCalEntry::EEvent, guid,

   874             CCalEntry::EMethodAdd, 0 );

   875     CleanupStack::PushL (entry );

   876     // iEntryUids->AppendL( *guid->Alloc() );

   877     

   878     entry->SetDescriptionL (parameters->iDescription->Des ( ) );

   879     entry->SetSummaryL (parameters->iSummary->Des ( ) );

   880 

   881     TCalTime startTime;

   882     TCalTime endTime;

   883     // Set the start and end times using time values local to the current system time zone

   884     startTime.SetTimeLocalL (parameters->iStartTime );

   885     endTime.SetTimeLocalL (parameters->iEndTime );

   886     entry->SetStartAndEndTimeL (startTime, endTime );

   887 

   888     // Repeating times:

   889     AddRepeatingRuleL(startTime, *entry, parameters);

   890     

   891     if( iSetAlarm || parameters->iUseRandomAlarmTime )

   892         {        

   893         SetRandomAlarmL(*entry);

   894         }

   895     else

   896         {

   897         SetAlarmL(*entry, parameters);

   898         }

   899     

   900     // Add attendees:

   901     AddAttendeesL(*entry, parameters);    

   902     

   903     if( parameters->IsAllowedEntryStatus(CCalEntry::EEvent, parameters->iStatus))

   904         {

   905         LOGSTRING2("Creator: CCreatorInterimCalendar::CreateEventEntryL setting entry status: %d", parameters->iStatus);

   906         entry->SetStatusL(parameters->iStatus);

   907         }

   908         

   909     RPointerArray<CCalEntry> array;

   910     CleanupClosePushL (array );

   911     array.AppendL (entry );

   912 

   913     TInt success(0);

   914     //If StoreL() leaves, 'success' contains the number of entries that were stored before it failed

   915     iCalEntryView->StoreL (array, success );

   916 

   917     // id has been generated, store it for being able to delete

   918     // entries created only with Creator

   919     iEntryIds.Append( entry->LocalUidL() );

   920     

   921     //One item should be added at time

   922     if (success != 1 )

   923         {

   924         err = 1;

   925         }

   926 

   927     CleanupStack::PopAndDestroy (&array );

   928     CleanupStack::PopAndDestroy (entry );

   929     CleanupStack::Pop (guid );//guid has been destroyed by entry, which has ownership to guid

   930     return err;

   931 

   932     }

   933 

   934 //----------------------------------------------------------------------------

   935 

   936 

   937 TInt CCreatorInterimCalendar::CreateReminderEntryL (

   938         CCreatorModuleBaseParameters *aParameters )

   939     {

   940     LOGSTRING("Creator: CCreatorInterimCalendar::CreateReminderEntryL");

   941 

   942     delete iParameters;

   943     iParameters = NULL;

   944     

   945     CCalenderInterimParameters* parameters = (CCalenderInterimParameters*)aParameters;

   946 

   947     // random data needed if no predefined data available

   948     if (!parameters )

   949         {

   950         iParameters = new(ELeave) CCalenderInterimParameters;

   951 

   952         iParameters->iRandomModeStartTime = iRandomModeStartTime;

   953         iParameters->iRandomModeEndTime = iRandomModeEndTime;

   954 

   955         // difference between start and end times

   956         TTimeIntervalDays

   957                 differenceInDays = iParameters->iRandomModeEndTime.DaysFrom (iParameters->iRandomModeStartTime );

   958 

   959         // due time (= something between the period start and end date)

   960         iParameters->iStartTime = iParameters->iRandomModeStartTime;

   961         iParameters->iStartTime

   962                 += TTimeIntervalDays (iEngine->RandomNumber (differenceInDays.Int ( ) ) );

   963 

   964         // strings

   965         iParameters->iDescription->Des()

   966                 = iEngine->RandomString (CCreatorEngine::EReminderText );

   967         

   968         iParameters->iSummary->Des() = iParameters->iDescription->Des();

   969 

   970         parameters = iParameters;

   971         }

   972 

   973     TInt err = KErrNone;

   974 

   975     HBufC8* guid = HBufC8::NewLC (255 );

   976     TPtr8 uidP=guid->Des ( );

   977     GenerateRandomId (uidP );

   978 

   979     CCalEntry* entry = CCalEntry::NewL (CCalEntry::EReminder, guid,

   980             CCalEntry::EMethodAdd, 0 );

   981     CleanupStack::PushL (entry );

   982 

   983     //Using same text as description and summary    

   984     entry->SetDescriptionL (parameters->iDescription->Des ( ) );

   985     entry->SetSummaryL (parameters->iSummary->Des ( ) );

   986 

   987     TCalTime startTime;

   988     TCalTime endTime;

   989     // Set the start and end times using time values local to the current system time zone

   990     startTime.SetTimeLocalL (parameters->iStartTime );

   991     TTime nullTime = Time::NullTTime ( );

   992     endTime.SetTimeLocalL (nullTime );

   993     entry->SetStartAndEndTimeL (startTime, endTime );

   994         

   995     if( parameters->IsAllowedEntryStatus(CCalEntry::EReminder, parameters->iStatus))

   996         {

   997         LOGSTRING2("Creator: CCreatorInterimCalendar::CreateReminderEntryL setting entry status: %d", parameters->iStatus);

   998         entry->SetStatusL(parameters->iStatus);

   999         }

  1000     

  1001     if( iSetAlarm || parameters->iUseRandomAlarmTime )

  1002         {        

  1003         SetRandomAlarmL(*entry);

  1004         }

  1005     else

  1006         {

  1007         SetAlarmL(*entry, parameters);

  1008         }

  1009 

  1010     RPointerArray<CCalEntry> array;

  1011     CleanupClosePushL (array );

  1012     array.AppendL (entry );

  1013 

  1014     TInt success(0);

  1015     //If StoreL() leaves, 'success' contains the number of entries that were stored before it failed

  1016     iCalEntryView->StoreL (array, success );

  1017 

  1018     // id has been generated, store it for being able to delete

  1019     // entries created only with Creator

  1020     iEntryIds.Append( entry->LocalUidL() );

  1021     

  1022     //One item should be added at time

  1023     if (success != 1 )

  1024         {

  1025         err = 1;

  1026         }

  1027 

  1028     CleanupStack::PopAndDestroy (&array );

  1029     CleanupStack::PopAndDestroy (entry );

  1030     CleanupStack::Pop (guid );//guid has been destroyed by entry, which has ownership to guid

  1031 

  1032     return err;

  1033     }

  1034 

  1035 //----------------------------------------------------------------------------

  1036 

  1037 TInt CCreatorInterimCalendar::CreateAnniversaryEntryL (

  1038         CCreatorModuleBaseParameters *aParameters )

  1039     {

  1040     LOGSTRING("Creator: CCreatorInterimCalendar::CreateAnniversaryEntryL");

  1041 

  1042     delete iParameters;

  1043     iParameters = NULL;

  1044     

  1045     CCalenderInterimParameters* parameters = (CCalenderInterimParameters*)aParameters;

  1046 

  1047     // random data needed if no predefined data available

  1048     if (!parameters )

  1049         {

  1050         iParameters = new(ELeave) CCalenderInterimParameters;

  1051 

  1052         iParameters->iRandomModeStartTime = iRandomModeStartTime;

  1053         iParameters->iRandomModeEndTime = iRandomModeEndTime;

  1054 

  1055         // difference between start and end times

  1056         TTimeIntervalDays differenceInDays = iParameters->iRandomModeEndTime.DaysFrom(iParameters->iRandomModeStartTime);  

  1057 

  1058         // start time (= something between the period start and end date)

  1059         iParameters->iStartTime = iParameters->iRandomModeStartTime;

  1060         iParameters->iStartTime += TTimeIntervalDays( iEngine->RandomNumber(differenceInDays.Int()) );        

  1061         

  1062         // strings

  1063         iParameters->iDescription->Des().Copy (iEngine->RandomString (CCreatorEngine::EFirstName ) );

  1064         iParameters->iDescription->Des().Append ( _L("'s ") );

  1065         iParameters->iDescription->Des().Append (iEngine->RandomString (CCreatorEngine::EAnniversaryReason ) );

  1066         iParameters->iSummary->Des() = iParameters->iDescription->Des();

  1067         parameters = iParameters;

  1068         }

  1069  

  1070     TInt err = KErrNone;

  1071 

  1072     HBufC8* guid = HBufC8::NewLC (255 );

  1073     TPtr8 uidP=guid->Des ( );

  1074     GenerateRandomId (uidP );

  1075 

  1076     CCalEntry* entry = CCalEntry::NewL (CCalEntry::EAnniv, guid,

  1077             CCalEntry::EMethodNone, 0 );

  1078     CleanupStack::PushL (entry );

  1079 

  1080     //Using same text as description and summary	

  1081     entry->SetDescriptionL (parameters->iDescription->Des ( ) );

  1082     entry->SetSummaryL (parameters->iSummary->Des ( ) );

  1083 

  1084     TCalTime startTime;

  1085     TCalTime endTime;

  1086     TTime nullTime = Time::NullTTime ( );

  1087     endTime.SetTimeLocalL (nullTime );

  1088     

  1089     // Set the start time using time value local to the current system time zone

  1090     startTime.SetTimeLocalL (parameters->iStartTime );

  1091 

  1092     entry->SetStartAndEndTimeL (startTime, endTime );

  1093 

  1094     if( iSetAlarm || parameters->iUseRandomAlarmTime )

  1095         {        

  1096         SetRandomAlarmL(*entry);

  1097         }

  1098     else

  1099         {

  1100         SetAlarmL(*entry, parameters);

  1101         }

  1102     

  1103     //set repeating rule

  1104     TCalRRule yearlyRptRule(TCalRRule::EYearly);

  1105     yearlyRptRule.SetDtStart (startTime );

  1106     //Set repeating until forever, not setting it to stop

  1107     //yearlyRptRule.SetUntil(endTime);

  1108     entry->SetRRuleL (yearlyRptRule );

  1109 

  1110     RPointerArray<CCalEntry> array;

  1111     CleanupClosePushL (array );

  1112     array.AppendL (entry );

  1113 

  1114     TInt success(0);

  1115     //If StoreL() leaves, 'success' contains the number of entries that were stored before it failed

  1116     iCalEntryView->StoreL (array, success );

  1117 

  1118     // id has been generated, store it for being able to delete

  1119     // entries created only with Creator

  1120     iEntryIds.Append( entry->LocalUidL() );

  1121     

  1122     //One item should be added at time

  1123     if (success != 1 )

  1124         {

  1125         err = 1;

  1126         }

  1127 

  1128     CleanupStack::PopAndDestroy (&array );

  1129     CleanupStack::PopAndDestroy (entry );

  1130     CleanupStack::Pop (guid );//guid has been destroyed by entry, which has ownership to guid

  1131 

  1132     return err;

  1133     }

  1134 

  1135 //----------------------------------------------------------------------------