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 #include "creator_contactsetcache.h"

    30 #include "creator_phonebook.h"

    31 

    32 static const TInt KCalendarFieldLength = 128;

    33 

    34 

    35 CCreatorCalenderAttendee::CCreatorCalenderAttendee() 

    36     {}

    37 

    38 CCreatorCalenderAttendee::~CCreatorCalenderAttendee()

    39     {

    40     delete iCommonName;

    41     delete iEmailAddress;

    42     }

    43 

    44 CCreatorCalenderAttendee* CCreatorCalenderAttendee::NewL()

    45     {

    46     CCreatorCalenderAttendee* self = new (ELeave) CCreatorCalenderAttendee;

    47     return self;

    48     }

    49 

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

    51     {

    52     delete iCommonName;

    53     iCommonName = 0;

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

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

    56     }

    57 

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

    59     {

    60     delete iEmailAddress;

    61     iEmailAddress = 0;

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

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

    64     }

    65 

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

    67     {

    68     iRole = aRole;

    69     }

    70 

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

    72     {

    73     iStatus = aStatus;

    74     }

    75 

    76 const TDesC& CCreatorCalenderAttendee::CommonName() const

    77     {

    78     if( iCommonName == 0 )

    79     	return iDummy;

    80     return *iCommonName;

    81     }

    82 

    83 const TDesC& CCreatorCalenderAttendee::EmailAddress() const

    84     {

    85     if( iEmailAddress == 0 )

    86     	return iDummy;

    87     

    88     return *iEmailAddress;

    89     }

    90 

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

    92     {

    93     return iRole;

    94     }

    95 

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

    97     {

    98     return iStatus;

    99     }

   100 

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

   102     {

   103     if( aType == CCalEntry::ETodo )

   104         {

   105         return  aStatus == CCalEntry::ECancelled ||

   106                 aStatus == CCalEntry::ETodoNeedsAction ||

   107                 aStatus == CCalEntry::ETodoCompleted ||

   108                 aStatus == CCalEntry::ETodoInProcess;

   109         }

   110     

   111     return  aStatus == CCalEntry::ETentative ||

   112             aStatus == CCalEntry::EConfirmed ||

   113             aStatus == CCalEntry::ECancelled;

   114     }

   115 

   116 //----------------------------------------------------------------------------

   117 

   118 CCalenderInterimParameters::CCalenderInterimParameters ( )

   119     {

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

   121 

   122     iAppointmentLocation = HBufC::New (KCalendarFieldLength );

   123     iAppointmentReason = HBufC::New (KCalendarFieldLength );

   124     iEventReason = HBufC::New (KCalendarFieldLength );

   125     iAnniversaryReason = HBufC::New (KCalendarFieldLength );

   126     iTodoTask = HBufC::New (KCalendarFieldLength );

   127     iReminderReason = HBufC::New (KCalendarFieldLength );

   128     iDescription = HBufC::New (KCalendarFieldLength );

   129     iSummary = HBufC::New (KCalendarFieldLength );

   130     iLocation = HBufC::New (KCalendarFieldLength );

   131     iOrganizerName = HBufC::New (KCalendarFieldLength );

   132     iOrganizerEmail = HBufC::New (KCalendarFieldLength );

   133 

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

   135     iRandomModeStartTime.HomeTime ( );

   136     iRandomModeEndTime = iRandomModeStartTime;

   137     iRandomModeEndTime += TTimeIntervalMonths (1 );

   138     iAlarmTime = Time::NullTTime();

   139     iUseRandomAlarmTime = EFalse;

   140     iStatus = CCalEntry::ENullStatus;

   141     }

   142 

   143 CCalenderInterimParameters::~CCalenderInterimParameters ( )

   144     {

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

   146 

   147     delete iTodoTask;

   148     delete iAnniversaryReason;

   149     delete iEventReason;

   150     delete iAppointmentReason;

   151     delete iAppointmentLocation;

   152     delete iReminderReason;

   153     delete iDescription;

   154     delete iSummary;

   155     delete iLocation;

   156     delete iOrganizerName;

   157     delete iOrganizerEmail;

   158     iAttendees.ResetAndDestroy();

   159     iAttendees.Close();

   160     iAttendeeLinkIds.Reset();

   161     iAttendeeLinkIds.Close();

   162     }

   163 

   164 void CCalenderInterimParameters::ParseL (CCommandParser* parser,

   165         TParseParams aCase )

   166     {

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

   168 

   169     HBufC* tempBuf= NULL;

   170 

   171     switch (aCase )

   172         {

   173 

   174         case MCreatorModuleBaseParameters::ECalendarTodo:

   175             {

   176 

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

   178 

   179             CleanupStack::PushL (tempBuf );

   180 

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

   182 

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

   184 

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

   186             this->iTodoPriority = 2;

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

   188                 this->iTodoPriority = 3;

   189             else

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

   191                     this->iTodoPriority = 1;

   192 

   193             CleanupStack::PopAndDestroy (tempBuf );

   194 

   195             }

   196             break;

   197 

   198         case MCreatorModuleBaseParameters::ECalendarMemo:

   199             {

   200 

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

   202 

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

   204 

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

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

   207 

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

   209 

   210             CleanupStack::PopAndDestroy (tempBuf );

   211             }

   212             break;

   213 

   214         case MCreatorModuleBaseParameters::ECalendarMeeting:

   215             {

   216 

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

   218 

   219             CleanupStack::PushL (tempBuf );

   220 

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

   222 

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

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

   225 

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

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

   228 

   229             CleanupStack::PopAndDestroy (tempBuf );

   230             }

   231             break;

   232 

   233         case MCreatorModuleBaseParameters::ECalendarAnniv:

   234             {

   235 

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

   237 

   238             CleanupStack::PushL (tempBuf );

   239 

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

   241 

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

   243 

   244             CleanupStack::PopAndDestroy (tempBuf );

   245 

   246             }

   247             break;

   248         default:

   249             {

   250             //implement 

   251             }

   252             break;

   253         }

   254     }

   255 //----------------------------------------------------------------------------

   256 

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

   258     {

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

   260     CleanupStack::Pop (self );

   261     return self;

   262     }

   263 

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

   265     {

   266     CCreatorInterimCalendar* self = new (ELeave) CCreatorInterimCalendar;

   267     CleanupStack::PushL (self );

   268     self->ConstructL (aEngine );

   269     return self;

   270     }

   271 

   272 CCreatorInterimCalendar::CCreatorInterimCalendar ( )

   273     {

   274     }

   275 

   276 void CCreatorInterimCalendar::ConstructL (CCreatorEngine* aEngine )

   277     {

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

   279 

   280     iEngine = aEngine;

   281 

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

   283     iRandomModeStartTime.HomeTime ( );

   284     iRandomModeEndTime = iRandomModeStartTime;

   285     iRandomModeEndTime += TTimeIntervalMonths (1 );

   286 

   287     iCalSession = CCalSession::NewL ( );

   288     // Create and open a calendar file

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

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

   291     ;

   292     // ignore KErrAlreadyExists leave code

   293     if (err != KErrAlreadyExists )

   294         {

   295         User::LeaveIfError (err );

   296         }

   297     // Open the calendar file

   298     iCalSession->OpenL (fileName );

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

   300     iNumberRepeatingEntries = 0;

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

   302     iSetAlarm = EFalse;

   303     iWaiter = CAsyncWaiter::NewL();

   304     }

   305 

   306 CCreatorInterimCalendar::~CCreatorInterimCalendar ( )

   307     {

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

   309 

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

   311         {

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

   313         }

   314         

   315     iEntryIds.Reset();

   316     iEntryIds.Close();

   317         

   318     if (iParameters )

   319         {

   320         delete iParameters;

   321         }

   322 

   323     if (iCalEntryView )

   324         {

   325         delete iCalEntryView;

   326         }

   327 

   328     if (iCalSession )

   329         {

   330         delete iCalSession;

   331         }

   332     delete iSoundFileArray;

   333     delete iWaiter;

   334     delete iTmpCN;

   335     delete iTmpEmail;

   336     }

   337 

   338 //----------------------------------------------------------------------------

   339 

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

   341     {

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

   343     

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

   345         {

   346         iEngine->ShutDownEnginesL();

   347         return;

   348         }

   349     

   350     const TDesC* showText = &KSavingText;

   351     TBool finished(EFalse);

   352     TBool retval(ETrue);

   353     switch(aUserData)

   354         {

   355         case ECreatorCalendarDelete:

   356             iEntriesToBeCreated = 1;

   357             showText = &KDeletingText;

   358             finished = ETrue;

   359             break;

   360         case ECreatorCalendarStart:

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

   362                 {

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

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

   365                 }

   366             else

   367                 {

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

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

   370                 }

   371             break;

   372         case ECreatorCalendarGetWeeklyEntries:

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

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

   375             break;

   376         case ECreatorCalendarGetAttendies:

   377             {

   378             // ask start date

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

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

   381             }

   382             break;

   383         case ECreatorCalendarGetStartDate:

   384             {

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

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

   387             }

   388             break;

   389         case ECreatorCalendarGetEndDate:

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

   391                 {

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

   393                 retval = EFalse;

   394                 }

   395             else 

   396                 {

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

   398                 }

   399            break;

   400         case ECreatorCalendarAddDefaultAlarm:

   401             iSetAlarm = aPositiveAction;

   402             finished = ETrue;

   403             break;

   404         default:

   405             //some error

   406             retval = EFalse;

   407             break;

   408         }

   409     if( retval == EFalse )

   410         {

   411         iEngine->ShutDownEnginesL();

   412         }

   413     else if( finished )

   414         {

   415         // add this command to command array

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

   417         // started exucuting commands

   418         iEngine->ExecuteFirstCommandL( *showText );

   419         }

   420     }

   421 

   422 //----------------------------------------------------------------------------

   423 

   424 TBool CCreatorInterimCalendar::AskDataFromUserL( TInt aCommand )

   425     {

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

   427     

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

   429     

   430     if( aCommand == ECmdDeleteCalendarEntries )

   431         {

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

   433         }

   434     if( aCommand == ECmdDeleteCreatorCalendarEntries )

   435         {

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

   437         }

   438 

   439     // display queries

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

   441     }

   442 

   443 //----------------------------------------------------------------------------

   444 

   445 TInt CCreatorInterimCalendar::CreateAppointmentEntryL (

   446         CCreatorModuleBaseParameters *aParameters )

   447     {

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

   449         

   450     delete iParameters;

   451     iParameters = 0;

   452     

   453     CCalenderInterimParameters* parameters = (CCalenderInterimParameters*)aParameters;   

   454     

   455     if( !parameters )

   456         {

   457         iParameters = new(ELeave) CCalenderInterimParameters;

   458         parameters = iParameters;  

   459         parameters->iRandomModeStartTime = iRandomModeStartTime;

   460         parameters->iRandomModeEndTime = iRandomModeEndTime;    

   461     

   462         // difference between start and end times

   463         TTimeIntervalMinutes differenceInMinutes;

   464         parameters->iRandomModeEndTime.MinutesFrom (

   465                 parameters->iRandomModeStartTime, differenceInMinutes );

   466 

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

   468         parameters->iStartTime = parameters->iRandomModeStartTime;

   469         parameters->iStartTime

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

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

   472         parameters->iEndTime = parameters->iStartTime;    

   473         parameters->iEndTime

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

   475         

   476 

   477         // strings        

   478         parameters->iLocation->Des ( )

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

   480         parameters->iDescription->Des ( )

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

   482         

   483         parameters->iSummary->Des()

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

   485         

   486         parameters->iNumberRepeatingEntries = iNumberRepeatingEntries;

   487         parameters->iNumberOfAttendees = iNumberOfAttendees;

   488         }

   489 

   490     TInt err = KErrNone;

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

   492     TPtr8 uidP=guid->Des ( );

   493     GenerateRandomId (uidP );

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

   495             CCalEntry::EMethodAdd, 0 );

   496     CleanupStack::PushL (entry );

   497 

   498     //Using same text as description and summary	

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

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

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

   502 

   503     TCalTime startTime;

   504     TCalTime endTime;

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

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

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

   508     startTime.SetTimeLocalL (parameters->iStartTime );

   509     endTime.SetTimeLocalL (parameters->iEndTime );

   510     entry->SetStartAndEndTimeL (startTime, endTime );       

   511     

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

   513         {

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

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

   516         }

   517     

   518     // Repeating times:

   519     AddRepeatingRuleL(startTime, *entry, parameters);

   520     SetOrganizerL(*entry, parameters);

   521     

   522     // Alarm:    

   523     if( iSetAlarm || parameters->iUseRandomAlarmTime )

   524         {        

   525         SetRandomAlarmL(*entry);

   526         }

   527     else

   528         {

   529         SetAlarmL(*entry, parameters);

   530         }

   531         

   532     // Add attendees:

   533     AddAttendeesL(*entry, parameters);

   534     

   535     RPointerArray<CCalEntry> array;

   536     CleanupClosePushL (array );

   537     array.AppendL (entry );

   538     

   539     TInt success(0);

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

   541     iCalEntryView->StoreL (array, success );

   542 

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

   544     // entries created only with Creator

   545     iEntryIds.AppendL( entry->LocalUidL() );

   546     

   547     //One item should be added at time

   548     if (success != 1 )

   549         {

   550         err = 1;

   551         }

   552 

   553     CleanupStack::PopAndDestroy (&array );

   554     CleanupStack::PopAndDestroy (entry );

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

   556 

   557     return err;

   558     }

   559 

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

   561     {    

   562     HBufC* orgName = 0;

   563     HBufC* orgEmail = 0;

   564     _LIT(KSpace, " ");

   565     

   566     //

   567     // Common name

   568     //

   569     if( parameters == 0 || 

   570         parameters->iOrganizerName == 0 || 

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

   572         {     

   573         // Random:

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

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

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

   577         CleanupStack::PushL(orgName);

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

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

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

   581         }

   582     else

   583         {

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

   585         CleanupStack::PushL(orgName);

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

   587         }

   588     

   589     //

   590     // Email

   591     //

   592     if( parameters == 0 ||

   593         parameters->iOrganizerEmail == 0 || 

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

   595         {        

   596         // Random:

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

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

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

   600         CleanupStack::PopAndDestroy(); // tmp

   601         CleanupStack::PushL(orgEmail);

   602         }

   603     else

   604         {

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

   606         CleanupStack::PushL(orgEmail);

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

   608         }

   609     

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

   611     CleanupStack::PopAndDestroy(); // orgName

   612     CleanupStack::PopAndDestroy(); // orgEmail

   613     }

   614 

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

   616     {

   617     RArray<TDay> days;

   618     CleanupClosePushL(days);

   619     

   620     // Recurrence rule. Weekly event.

   621     if( parameters->iNumberRepeatingEntries > 0 )

   622         {

   623         TCalRRule calRepeat(TCalRRule::EWeekly);   

   624         calRepeat.SetDtStart(aStartTime);

   625         calRepeat.SetCount(parameters->iNumberRepeatingEntries);        

   626         calRepeat.SetInterval(1);

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

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

   629         days.AppendL(tempDay);

   630         calRepeat.SetByDay(days);        

   631         aCalEntry.SetRRuleL(calRepeat);

   632         }

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

   634         {

   635         TCalTime calTime;        

   636         // Recurrent frequency

   637         TCalRRule calRepeat(parameters->iRecurrentFrequency);

   638         // Recurrent start        

   639         calRepeat.SetDtStart(aStartTime);

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

   641         	{

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

   643         	days.AppendL(tempDay);        

   644         	calRepeat.SetByDay(days);  

   645         	}

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

   647         	{

   648         	RArray< TInt > daysInMonth;

   649         	CleanupClosePushL(daysInMonth);

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

   651         	calRepeat.SetByMonthDay(daysInMonth);

   652         	CleanupStack::PopAndDestroy(&daysInMonth);

   653         	}

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

   655         	{

   656         	RArray< TMonth > monthsInYear;

   657         	CleanupClosePushL(monthsInYear);

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

   659         	calRepeat.SetByMonth(monthsInYear);

   660         	CleanupStack::PopAndDestroy(&monthsInYear);

   661         	}

   662         

   663         // Recurrent interval

   664         if( parameters->iRecurrentInterval > 0 )

   665         	calRepeat.SetInterval(parameters->iRecurrentInterval);

   666                 

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

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

   669         if( parameters->iRepeatingCount > 0 )

   670             {

   671             calRepeat.SetCount(parameters->iRepeatingCount);

   672             aCalEntry.SetRRuleL(calRepeat);            

   673             }

   674         else

   675             {

   676             TCalTime endTime;

   677             endTime.SetTimeLocalL(parameters->iRecurrentEndTime);

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

   679             	{

   680             	calRepeat.SetUntil(endTime);

   681             	aCalEntry.SetRRuleL(calRepeat);

   682             	}

   683             }           

   684         }

   685     CleanupStack::PopAndDestroy(&days);

   686     }

   687 

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

   689     {

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

   691         {

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

   693         CleanupStack::PushL(alarm);

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

   695         //	{

   696         	TTimeIntervalMinutes diff;

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

   698         	if( err == KErrNone)

   699         		{

   700         		alarm->SetTimeOffset(diff);

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

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

   703         			{

   704         			User::Leave(err);

   705         			}        		

   706         		}

   707         //	}

   708         CleanupStack::PopAndDestroy(alarm);

   709         }

   710     }

   711 

   712 void CCreatorInterimCalendar::SetRandomAlarmL(CCalEntry& aCalEntry)

   713     {

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

   715     CleanupStack::PushL(alarm);

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

   717     

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

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

   720     	{

   721     	User::Leave(err);

   722     	}

   723     CleanupStack::PopAndDestroy(alarm);

   724     }

   725 

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

   727     {

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

   729     CleanupStack::PushL(phOwner);

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

   731     CleanupStack::Pop(phOwner);

   732     if( err == KErrNone )

   733         {

   734         phOwner->SetCommonNameL(aCN);

   735         }

   736     else

   737         {

   738         delete phOwner;

   739         }

   740     }

   741 

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

   743     {

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

   745     CleanupStack::PushL(organizer);

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

   747     CleanupStack::Pop(organizer);

   748     if( err == KErrNone )

   749         {

   750         organizer->SetCommonNameL(aCN);

   751         }

   752     else

   753         {

   754         delete organizer;

   755         }

   756     }

   757 

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

   759     {

   760     if( !parameters )

   761         return;

   762             

   763     // Random attendees:

   764     TInt numOfAttendees = parameters->iNumberOfAttendees;

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

   766         {

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

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

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

   770         _LIT(KCountry, "com");        

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

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

   773         CleanupStack::PushL(attendee);

   774         aCalEntry.AddAttendeeL(attendee);

   775         CleanupStack::Pop(attendee);

   776         attendee->SetCommonNameL(firstname);

   777                 

   778         // Set phone owner:

   779         if( i == 1 )

   780             {             

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

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

   783             }

   784         // Set organizer:

   785         else if ( i == 0 )

   786             {            

   787             // Organizer is the chairman of the meeting:

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

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

   790             }

   791         else if( i % 3 == 0 )

   792             {

   793             // every third attendee is optional:

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

   795             }

   796         else

   797             {

   798             // Others are required attendees:

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

   800             }

   801         

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

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

   804         

   805         CleanupStack::PopAndDestroy(emailAddr);

   806         }

   807     

   808     // Explicit attendees:

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

   810         {

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

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

   813         	{

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

   815         	CleanupStack::PushL(attendee);

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

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

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

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

   820         	attendee->SetResponseRequested(ETrue);

   821         	aCalEntry.AddAttendeeL(attendee);

   822         	CleanupStack::Pop(); // attendee

   823         	}

   824         }

   825     // linked attendees:

   826      for( TInt i = 0; i < parameters->iAttendeeLinkIds.Count(); ++i )

   827         {

   828         CCreatorPhonebook* phonebook = dynamic_cast<CCreatorPhonebook*>(iEngine->GetPhonebook());

   829         User::LeaveIfNull( phonebook );

   830         CCreatorPhonebookWrapper* phonebookWrapper = phonebook->GetPhonebookWrapper();

   831         

   832         TLinkIdParam attendeeLinkId = parameters->iAttendeeLinkIds[i];

   833         const CCreatorContactSet& set = ContactLinkCache::Instance()->ContactSet(attendeeLinkId.iLinkId);

   834         const RArray<TUint32> links = set.ContactLinks();

   835         TInt numberOfExplicitLinks = links.Count(); // Number of defined contacts in contact-set

   836         for( TInt j = 0; j < numberOfExplicitLinks; ++j )

   837             {

   838             TBuf<128> email;

   839             TBuf<128> name;

   840             TBuf<128> phoneNumber;

   841             phonebookWrapper->GetContactDetailsL( links[j], name, phoneNumber, email );

   842             CCalAttendee* attendee = CCalAttendee::NewL( email );

   843             CleanupStack::PushL(attendee);

   844             if( name.Length() > 0 )

   845                 attendee->SetCommonNameL( name );

   846             attendee->SetResponseRequested(ETrue);

   847             aCalEntry.AddAttendeeL(attendee);

   848             CleanupStack::Pop(); // attendee

   849             }

   850         }

   851     }

   852 //----------------------------------------------------------------------------

   853 

   854 TInt CCreatorInterimCalendar::CreateEventEntryL (

   855         CCreatorModuleBaseParameters *aParameters )

   856     {

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

   858 

   859     delete iParameters;

   860     iParameters = 0;

   861         

   862     CCalenderInterimParameters* parameters = (CCalenderInterimParameters*)aParameters;       

   863     

   864     // random data needed if no predefined data available

   865     if (!parameters )

   866         {

   867         iParameters = new(ELeave) CCalenderInterimParameters;

   868 

   869         iParameters->iRandomModeStartTime = iRandomModeStartTime;

   870         iParameters->iRandomModeEndTime = iRandomModeEndTime;

   871         iParameters->iNumberRepeatingEntries = iNumberRepeatingEntries;

   872         iParameters->iNumberOfAttendees = iNumberOfAttendees;

   873         

   874         // difference between start and end times

   875         TTimeIntervalMinutes differenceInMinutes;

   876         iParameters->iRandomModeEndTime.MinutesFrom (

   877                 iParameters->iRandomModeStartTime, differenceInMinutes );

   878 

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

   880         iParameters->iStartTime = iParameters->iRandomModeStartTime;

   881         iParameters->iStartTime

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

   883 

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

   885         iParameters->iEndTime = iParameters->iStartTime;

   886         iParameters->iEndTime

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

   888 

   889         // strings

   890         iParameters->iDescription->Des()

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

   892         

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

   894         

   895         // Random event status:

   896         iParameters->iStatus = 

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

   898         

   899         parameters = iParameters;

   900         }

   901 

   902     TInt err = KErrNone;

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

   904     TPtr8 uidP=guid->Des ( );

   905     GenerateRandomId (uidP );

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

   907             CCalEntry::EMethodAdd, 0 );

   908     CleanupStack::PushL (entry );

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

   910     

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

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

   913 

   914     TCalTime startTime;

   915     TCalTime endTime;

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

   917     startTime.SetTimeLocalL (parameters->iStartTime );

   918     endTime.SetTimeLocalL (parameters->iEndTime );

   919     entry->SetStartAndEndTimeL (startTime, endTime );

   920 

   921     // Repeating times:

   922     AddRepeatingRuleL(startTime, *entry, parameters);

   923     

   924     if( iSetAlarm || parameters->iUseRandomAlarmTime )

   925         {        

   926         SetRandomAlarmL(*entry);

   927         }

   928     else

   929         {

   930         SetAlarmL(*entry, parameters);

   931         }

   932     

   933     // Add attendees:

   934     AddAttendeesL(*entry, parameters);    

   935     

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

   937         {

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

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

   940         }

   941         

   942     RPointerArray<CCalEntry> array;

   943     CleanupClosePushL (array );

   944     array.AppendL (entry );

   945 

   946     TInt success(0);

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

   948     iCalEntryView->StoreL (array, success );

   949 

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

   951     // entries created only with Creator

   952     iEntryIds.AppendL( entry->LocalUidL() );

   953     

   954     //One item should be added at time

   955     if (success != 1 )

   956         {

   957         err = 1;

   958         }

   959 

   960     CleanupStack::PopAndDestroy (&array );

   961     CleanupStack::PopAndDestroy (entry );

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

   963     return err;

   964 

   965     }

   966 

   967 //----------------------------------------------------------------------------

   968 

   969 

   970 TInt CCreatorInterimCalendar::CreateReminderEntryL (

   971         CCreatorModuleBaseParameters *aParameters )

   972     {

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

   974 

   975     delete iParameters;

   976     iParameters = NULL;

   977     

   978     CCalenderInterimParameters* parameters = (CCalenderInterimParameters*)aParameters;

   979 

   980     // random data needed if no predefined data available

   981     if (!parameters )

   982         {

   983         iParameters = new(ELeave) CCalenderInterimParameters;

   984 

   985         iParameters->iRandomModeStartTime = iRandomModeStartTime;

   986         iParameters->iRandomModeEndTime = iRandomModeEndTime;

   987 

   988         // difference between start and end times

   989         TTimeIntervalDays

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

   991 

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

   993         iParameters->iStartTime = iParameters->iRandomModeStartTime;

   994         iParameters->iStartTime

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

   996 

   997         // strings

   998         iParameters->iDescription->Des()

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

  1000         

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

  1002 

  1003         parameters = iParameters;

  1004         }

  1005 

  1006     TInt err = KErrNone;

  1007 

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

  1009     TPtr8 uidP=guid->Des ( );

  1010     GenerateRandomId (uidP );

  1011 

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

  1013             CCalEntry::EMethodAdd, 0 );

  1014     CleanupStack::PushL (entry );

  1015 

  1016     //Using same text as description and summary    

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

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

  1019 

  1020     TCalTime startTime;

  1021     TCalTime endTime;

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

  1023     startTime.SetTimeLocalL (parameters->iStartTime );

  1024     TTime nullTime = Time::NullTTime ( );

  1025     endTime.SetTimeLocalL (nullTime );

  1026     entry->SetStartAndEndTimeL (startTime, endTime );

  1027         

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

  1029         {

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

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

  1032         }

  1033     

  1034     if( iSetAlarm || parameters->iUseRandomAlarmTime )

  1035         {        

  1036         SetRandomAlarmL(*entry);

  1037         }

  1038     else

  1039         {

  1040         SetAlarmL(*entry, parameters);

  1041         }

  1042 

  1043     RPointerArray<CCalEntry> array;

  1044     CleanupClosePushL (array );

  1045     array.AppendL (entry );

  1046 

  1047     TInt success(0);

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

  1049     iCalEntryView->StoreL (array, success );

  1050 

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

  1052     // entries created only with Creator

  1053     iEntryIds.AppendL( entry->LocalUidL() );

  1054     

  1055     //One item should be added at time

  1056     if (success != 1 )

  1057         {

  1058         err = 1;

  1059         }

  1060 

  1061     CleanupStack::PopAndDestroy (&array );

  1062     CleanupStack::PopAndDestroy (entry );

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

  1064 

  1065     return err;

  1066     }

  1067 

  1068 //----------------------------------------------------------------------------

  1069 

  1070 TInt CCreatorInterimCalendar::CreateAnniversaryEntryL (

  1071         CCreatorModuleBaseParameters *aParameters )

  1072     {

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

  1074 

  1075     delete iParameters;

  1076     iParameters = NULL;

  1077     

  1078     CCalenderInterimParameters* parameters = (CCalenderInterimParameters*)aParameters;

  1079 

  1080     // random data needed if no predefined data available

  1081     if (!parameters )

  1082         {

  1083         iParameters = new(ELeave) CCalenderInterimParameters;

  1084 

  1085         iParameters->iRandomModeStartTime = iRandomModeStartTime;

  1086         iParameters->iRandomModeEndTime = iRandomModeEndTime;

  1087 

  1088         // difference between start and end times

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

  1090 

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

  1092         iParameters->iStartTime = iParameters->iRandomModeStartTime;

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

  1094         

  1095         // strings

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

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

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

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

  1100         parameters = iParameters;

  1101         }

  1102  

  1103     TInt err = KErrNone;

  1104 

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

  1106     TPtr8 uidP=guid->Des ( );

  1107     GenerateRandomId (uidP );

  1108 

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

  1110             CCalEntry::EMethodNone, 0 );

  1111     CleanupStack::PushL (entry );

  1112 

  1113     //Using same text as description and summary	

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

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

  1116 

  1117     TCalTime startTime;

  1118     TCalTime endTime;

  1119     TTime nullTime = Time::NullTTime ( );

  1120     endTime.SetTimeLocalL (nullTime );

  1121     

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

  1123     startTime.SetTimeLocalL (parameters->iStartTime );

  1124 

  1125     entry->SetStartAndEndTimeL (startTime, endTime );

  1126 

  1127     if( iSetAlarm || parameters->iUseRandomAlarmTime )

  1128         {        

  1129         SetRandomAlarmL(*entry);

  1130         }

  1131     else

  1132         {

  1133         SetAlarmL(*entry, parameters);

  1134         }