1 /*

     2 * Copyright (c) 2007-2009 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:  ESMR MR Entry implementation

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include "cesmrmeetingrequestentry.h"

    21 #include "cesmrfsmailboxutils.h"

    22 #include "cesmrcaldbmgr.h"

    23 #include "esmrhelper.h"

    24 #include "esmrentryhelper.h"

    25 #include "cesmrconflictchecker.h"

    26 #include "cesmrcaluserutil.h"

    27 #include "cesmralarminfohandler.h"

    28 #include "cesmrrecurrenceinfohandler.h"

    29 #include "mmrinfoobject.h"

    30 #include "mmrattendee.h"

    31 

    32 #include "cfsmailmessage.h"

    33 

    34 #include "esmrconfig.hrh"

    35 #include "cesmrfeaturesettings.h"

    36 

    37 #include "emailtrace.h"

    38 

    39 #include <esmralarminfo.rsg>

    40 #include <calentry.h>

    41 #include <calinstance.h>

    42 #include <calinstanceview.h>

    43 #include <caluser.h>

    44 #include <calattachment.h>

    45 #include <CalenInterimUtils2.h>

    46 #include <cmrmailboxutils.h>

    47 #include <calrrule.h>

    48 #include <centralrepository.h>

    49 #include <calalarm.h>

    50 #include <CalendarInternalCRKeys.h>

    51 #include <data_caging_path_literals.hrh>

    52 #include <coemain.h>

    53 #include <calentryview.h>

    54 #include <ct/rcpointerarray.h>

    55 #include <apmstd.h>

    56 #include <apgcli.h>

    57 #include <apmrec.h>

    58 

    59 /// Unnamed namespace for local definitions

    60 namespace {

    61 

    62 // Alarm resource file location

    63 _LIT( KAlarmInfoResource, "esmralarminfo.rsc" );

    64 

    65 // Definition for default alarm time for meeting

    66 const TInt KDefaultMeetingAlarmMinutes( 15 );

    67 

    68 _LIT( KReplaceLineFeedChar, "\n" );

    69 _LIT( KLineFeed, "\x2029");

    70 

    71 /**

    72  * Sets phone owner to entry.

    73  * @param aMbUtils Reference to mailbox utils.

    74  * @param aEntry Reference to calendar entry.

    75  */

    76 void SetPhoneOwnerL(

    77         CMRMailboxUtils& aMbUtils,

    78         CCalEntry& aEntry )

    79     {

    80     CESMRFsMailboxUtils* fsMbUtils =

    81             CESMRFsMailboxUtils::NewL( aMbUtils );

    82     CleanupStack::PushL( fsMbUtils );

    83 

    84     fsMbUtils->SetPhoneOwnerL( aEntry );

    85     CleanupStack::PopAndDestroy( fsMbUtils );

    86     fsMbUtils = NULL;

    87     }

    88 

    89 /**

    90  * Makes copy of the entry and sets phone owner accordingly

    91  * @param aMbUtils Reference to mailbox utils.

    92  * @param aEntry Reference to calendar entry.

    93  */

    94 CCalEntry* CopyEntryL(

    95         CMRMailboxUtils& aMbUtils,

    96         const CCalEntry& aEntry )

    97     {

    98     CCalEntry* entry = ESMRHelper::CopyEntryL(

    99                             aEntry,

   100                             aEntry.MethodL(),

   101                             ESMRHelper::ECopyFull,

   102                             EESMREventTypeMeetingRequest );

   103 

   104     SetPhoneOwnerL( aMbUtils, *entry );

   105 

   106     return entry;

   107     }

   108 

   109 #ifdef _DEBUG

   110 

   111 // Definition for panic text

   112 _LIT( KESMREntryPanicTxt, "ESMRMeetingRequestEntry" );

   113 

   114 /**

   115  * ES MR Entry panic codes

   116  */

   117 enum TESMRMeetingRequestEntry

   118     {

   119     EESMREntryNotExist = 1, // Entry does not exist

   120     EESMRInvalidRole,       // Phone owner has invalid role

   121     EESMRNoInfoObjectAttendeeFound,

   122     EESMRPhoneOwnerNotSet,

   123     EESMRRecurrenceError,

   124     EESMRInvalidReplyType,

   125     EESMRInvalidInvalidAttendeeStatus,

   126     EESMRParentNotFound

   127     };

   128 

   129 /**

   130  * Raises panic.

   131  * @param aPanic Panic code

   132  */

   133 void Panic(TESMRMeetingRequestEntry aPanic)

   134     {

   135     User::Panic( KESMREntryPanicTxt, aPanic);

   136     }

   137 

   138 #endif // _DEBUG

   139 

   140 }  // namespace

   141 

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

   143 

   144 // ---------------------------------------------------------------------------

   145 // CESMRMeetingRequestEntry::CESMRMeetingRequestEntry

   146 // ---------------------------------------------------------------------------

   147 //

   148 inline CESMRMeetingRequestEntry::CESMRMeetingRequestEntry(

   149         CMRMailboxUtils& aMRMailboxUtils,

   150         MESMRCalDbMgr& aCalDb,

   151         TBool aConflictsExists,

   152         TESMRInputParams* aESMRInputParams )

   153 :   iMRMailboxUtils( aMRMailboxUtils ),

   154     iConflictsExists( aConflictsExists),

   155     iCalDb( aCalDb ),

   156     iESMRInputParams( aESMRInputParams ),

   157     iSendCanellation( ETrue )

   158     {

   159     FUNC_LOG;

   160     // Not yet implementation

   161     }

   162 

   163 // ---------------------------------------------------------------------------

   164 // CESMRMeetingRequestEntry::~CESMRMeetingRequestEntry

   165 // ---------------------------------------------------------------------------

   166 //

   167 EXPORT_C CESMRMeetingRequestEntry::~CESMRMeetingRequestEntry()

   168     {

   169     FUNC_LOG;

   170     delete iEntry;

   171     delete iForwardEntry;

   172     delete iOrginalEntry;

   173     delete iParameterEntry;

   174     }

   175 

   176 // ---------------------------------------------------------------------------

   177 // CESMRMeetingRequestEntry::NewL

   178 // ---------------------------------------------------------------------------

   179 //

   180 EXPORT_C CESMRMeetingRequestEntry* CESMRMeetingRequestEntry::NewL(

   181         const CCalEntry& aEntry,

   182         CMRMailboxUtils& aMRMailboxUtils,

   183         MESMRCalDbMgr& aCalDb,

   184         TBool aConflictsExists,

   185         TESMRInputParams* aESMRInputParams )

   186     {

   187     FUNC_LOG;

   188 

   189     CESMRMeetingRequestEntry* self =

   190             new (ELeave) CESMRMeetingRequestEntry(

   191                 aMRMailboxUtils,

   192                 aCalDb,

   193                 aConflictsExists,

   194                 aESMRInputParams );

   195 

   196     CleanupStack::PushL( self );

   197     self->ConstructL( aEntry );

   198     CleanupStack::Pop( self );

   199 

   200     return self;

   201     }

   202 

   203 // ---------------------------------------------------------------------------

   204 // CESMRMeetingRequestEntry::ConstructL

   205 // ---------------------------------------------------------------------------

   206 //

   207 void CESMRMeetingRequestEntry::ConstructL(

   208         const CCalEntry& aEntry )

   209     {

   210     FUNC_LOG;

   211 

   212     iParameterEntry = CopyEntryL( iMRMailboxUtils, aEntry );

   213     iEntry = CopyEntryL( iMRMailboxUtils, aEntry );

   214 

   215     iOrginalEntry  = CopyEntryL( iMRMailboxUtils, aEntry );

   216 

   217     if ( EESMRRoleOrganizer == RoleL() && IsStoredL() )

   218         {

   219         // Increase sequence number

   220         TInt seqNo( iEntry->SequenceNumberL() + 1);

   221         iEntry->SetSequenceNumberL( seqNo );

   222         iOrginalEntry->SetSequenceNumberL( seqNo );

   223         }

   224 

   225 

   226     CCalEntry::TMethod method( iEntry->MethodL() );

   227 

   228     if ( CCalEntry::EMethodNone == method )

   229         {

   230         iEntry->SetMethodL( CCalEntry::EMethodRequest );

   231         iOrginalEntry->SetMethodL( CCalEntry::EMethodRequest );

   232         }

   233 

   234     HBufC* newDescription = ReplaceCharactersFromBufferLC(

   235                                     iEntry->DescriptionL(),

   236                                     KReplaceLineFeedChar(),

   237                                     KLineFeed() );

   238     iEntry->SetDescriptionL( *newDescription );

   239     iOrginalEntry->SetDescriptionL( *newDescription );

   240 

   241     CleanupStack::PopAndDestroy( newDescription );

   242 

   243     __ASSERT_DEBUG( iEntry->PhoneOwnerL(), Panic( EESMRPhoneOwnerNotSet) );

   244 

   245     CESMRFeatureSettings* settings = CESMRFeatureSettings::NewL();

   246     if ( settings->FeatureSupported(

   247             CESMRFeatureSettings::EMRUIMeetingRequestViewerCmailOnly ) )

   248         {

   249         // Meeting request viewer available only from email.

   250         // Remove attachments from entry.

   251         iRemoveAttachments = ETrue;

   252         }

   253     delete settings;

   254 

   255     if ( CurrentPluginL() == EESMRActiveSync )

   256         {

   257         // Set correct calendar database

   258         SetDefaultDatabaseL();

   259         }

   260     }

   261 

   262 // ---------------------------------------------------------------------------

   263 // CESMRMeetingRequestEntry::ReplaceCharactersFromBufferL

   264 // ---------------------------------------------------------------------------

   265 //

   266 HBufC* CESMRMeetingRequestEntry::ReplaceCharactersFromBufferLC( const TDesC& aTarget,

   267                               const TDesC& aFindString,

   268                               const TDesC& aReplacement )

   269     {

   270     FUNC_LOG;

   271     HBufC* newBuffer = aTarget.AllocLC();

   272     TPtr16 ptr = newBuffer->Des();

   273 

   274     // find next occurance:

   275     TInt offset = ptr.Find(aFindString);

   276     while ( offset != KErrNotFound )

   277         {

   278         // replace the data:

   279         ptr.Replace( offset, aFindString.Length(), aReplacement);

   280 

   281         // find next occurance:

   282         offset = ptr.Find(aFindString);

   283         }

   284 

   285     return newBuffer;

   286     }

   287 

   288 // ---------------------------------------------------------------------------

   289 // CESMRMeetingRequestEntry::Type

   290 // ---------------------------------------------------------------------------

   291 //

   292 MESMRCalEntry::TESMRCalEntryType CESMRMeetingRequestEntry::Type() const

   293     {

   294     FUNC_LOG;

   295     // This is meeting request

   296     return MESMRCalEntry::EESMRCalEntryMeetingRequest;

   297     }

   298 

   299 // ---------------------------------------------------------------------------

   300 // CESMRMeetingRequestEntry::MESMRCalEntryRef

   301 // ---------------------------------------------------------------------------

   302 //

   303 MESMRCalEntry& CESMRMeetingRequestEntry::MESMRCalEntryRef()

   304     {

   305     FUNC_LOG;

   306     return *this;

   307     }

   308 

   309 // ---------------------------------------------------------------------------

   310 // CESMRMeetingRequestEntry::MESMRCalEntryRef

   311 // ---------------------------------------------------------------------------

   312 //

   313 const MESMRCalEntry& CESMRMeetingRequestEntry::MESMRCalEntryRef() const

   314     {

   315     FUNC_LOG;

   316     return *this;

   317     }

   318 // ---------------------------------------------------------------------------

   319 // CESMRMeetingRequestEntry::Entry

   320 // ---------------------------------------------------------------------------

   321 //

   322 CCalEntry& CESMRMeetingRequestEntry::Entry()

   323     {

   324     FUNC_LOG;

   325     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   326 

   327     if ( iForwardEntry )

   328         {

   329         return *iForwardEntry;

   330         }

   331 

   332     return *iEntry;

   333     }

   334 

   335 // ---------------------------------------------------------------------------

   336 // CESMRMeetingRequestEntry::Entry

   337 // ---------------------------------------------------------------------------

   338 //

   339 const CCalEntry& CESMRMeetingRequestEntry::Entry() const

   340     {

   341     FUNC_LOG;

   342     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   343     if ( iForwardEntry )

   344         {

   345         return *iForwardEntry;

   346         }

   347     return *iEntry;

   348     }

   349 

   350 // ---------------------------------------------------------------------------

   351 // CESMRMeetingRequestEntry::InstanceL

   352 // ---------------------------------------------------------------------------

   353 //

   354 CCalInstance* CESMRMeetingRequestEntry::InstanceL() const

   355     {

   356     FUNC_LOG;

   357 

   358     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   359     __ASSERT_DEBUG( iOrginalEntry, Panic(EESMREntryNotExist ) );

   360 

   361     CCalInstance* instance = NULL;

   362 

   363     instance = iCalDb.FindInstanceL( *iEntry );

   364     if ( !instance )

   365         {

   366         // Instance not found by using the edited entry

   367         // Trying with orginal.

   368         instance = iCalDb.FindInstanceL( *iOrginalEntry );

   369         }

   370 

   371     if ( !instance )

   372         {

   373         // Instance not found by using edited or orginal entry.

   374         // --> Leave

   375         User::Leave( KErrNotFound );

   376         }

   377 

   378     return instance;

   379     }

   380 

   381 // ---------------------------------------------------------------------------

   382 // CESMRMeetingRequestEntry::CanSetRecurrenceL

   383 // ---------------------------------------------------------------------------

   384 //

   385 TBool CESMRMeetingRequestEntry::CanSetRecurrenceL() const

   386     {

   387     FUNC_LOG;

   388 

   389     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   390 

   391     TBool canSetRecurrence( ETrue );

   392 

   393     if ( iEntry->EntryTypeL() == CCalEntry::EAppt &&

   394             ESMREntryHelper::IsRepeatingMeetingL(*iEntry) &&

   395         (!ESMREntryHelper::IsModifyingEntryL(*iEntry) &&

   396           MESMRCalEntry::EESMRThisOnly == iRecurrenceModRule ))

   397         {

   398         canSetRecurrence = EFalse;

   399         }

   400 

   401 

   402     return canSetRecurrence;

   403     }

   404 

   405 // ---------------------------------------------------------------------------

   406 // CESMRMeetingRequestEntry::IsRecurrentEventL

   407 // ---------------------------------------------------------------------------

   408 //

   409 TBool CESMRMeetingRequestEntry::IsRecurrentEventL() const

   410     {

   411     FUNC_LOG;

   412 

   413     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   414 

   415     TBool recurrenceEvent( EFalse );

   416     if ( IsStoredL() )

   417         {

   418         // Entry is stored in calendar db

   419         // Lets look recurrence using instance

   420 

   421         // Ownership is transferred

   422         CCalInstance* instance = NULL;

   423         TRAPD(err, instance = InstanceL() );

   424         if ( KErrNotFound != err )

   425             {

   426             User::LeaveIfError( err );

   427             }

   428 

   429         if ( instance )

   430             {

   431             CleanupStack::PushL( instance );

   432 

   433             CCalEntry& instanceParentEntry = instance->Entry();

   434 

   435             if ( ESMREntryHelper::IsRepeatingMeetingL( instanceParentEntry ) )

   436                 {

   437                 recurrenceEvent = ETrue;

   438                 }

   439             CleanupStack::PopAndDestroy( instance );

   440             }

   441         else if ( ESMREntryHelper::IsRepeatingMeetingL( *iEntry ) )

   442             {

   443             recurrenceEvent = ETrue;

   444             }

   445         }

   446     else

   447         {

   448         // Entry is not stored in calendar db

   449         if ( ESMREntryHelper::IsRepeatingMeetingL( *iEntry ) )

   450             {

   451             // This is repeating meeting

   452             recurrenceEvent = ETrue;

   453             }

   454         }

   455 

   456 

   457     return recurrenceEvent;

   458     }

   459 

   460 // ---------------------------------------------------------------------------

   461 // CESMRMeetingRequestEntry::SetRecurrenceL

   462 //

   463 // ---------------------------------------------------------------------------

   464 //

   465 void CESMRMeetingRequestEntry::SetRecurrenceL(

   466         TESMRRecurrenceValue aRecurrence,

   467         TTime aUntil )

   468     {

   469     FUNC_LOG;

   470 

   471     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   472 

   473     // Check if this entry's recurrence can be edited

   474     if ( !CanSetRecurrenceL() )

   475         {

   476         User::Leave( KErrNotSupported );

   477         }

   478 

   479     if ( aRecurrence != ERecurrenceNot &&

   480             MESMRCalEntry::EESMRAllInSeries != iRecurrenceModRule )

   481         {

   482         // Make sure that mod rule is correct

   483         SetModifyingRuleL(

   484                 MESMRCalEntry::EESMRAllInSeries );

   485         }

   486 

   487     CESMRRecurrenceInfoHandler* recurrenceHandler =

   488             CESMRRecurrenceInfoHandler::NewLC( *iEntry );

   489 

   490     recurrenceHandler->SetRecurrenceL( aRecurrence, aUntil );

   491 

   492     CleanupStack::PopAndDestroy( recurrenceHandler );

   493 

   494     }

   495 

   496 // ---------------------------------------------------------------------------

   497 // CESMRMeetingRequestEntry::GetRecurrenceL

   498 //

   499 // ---------------------------------------------------------------------------

   500 //

   501 void CESMRMeetingRequestEntry::GetRecurrenceL(

   502         TESMRRecurrenceValue& aRecurrence,

   503         TTime& aUntil) const

   504     {

   505     FUNC_LOG;

   506 

   507     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   508 

   509     CESMRRecurrenceInfoHandler* recurrenceHandler =

   510             CESMRRecurrenceInfoHandler::NewLC( *iEntry, &iCalDb );

   511 

   512     recurrenceHandler->GetRecurrenceL( aRecurrence, aUntil );

   513     CleanupStack::PopAndDestroy( recurrenceHandler );

   514     }

   515 

   516 // ---------------------------------------------------------------------------

   517 // CESMRMeetingRequestEntry::RecurrenceModRule

   518 // ---------------------------------------------------------------------------

   519 //

   520 MESMRCalEntry::TESMRRecurrenceModifyingRule

   521     CESMRMeetingRequestEntry::RecurrenceModRule() const

   522     {

   523     return iRecurrenceModRule;

   524     }

   525 

   526 // ---------------------------------------------------------------------------

   527 // CESMRMeetingRequestEntry::SetModifyingRuleL

   528 // ---------------------------------------------------------------------------

   529 //

   530 void CESMRMeetingRequestEntry::SetModifyingRuleL(

   531         TESMRRecurrenceModifyingRule aRule, const TBool aTypeChanging )

   532     {

   533     FUNC_LOG;

   534 

   535     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   536 

   537     CESMRRecurrenceInfoHandler* recHandler =

   538             CESMRRecurrenceInfoHandler::NewL( *iOrginalEntry );

   539     CleanupStack::PushL( recHandler );

   540 

   541     TESMRRecurrenceValue orginalRecurrence;

   542     TTime orginalUntil;

   543 

   544     recHandler->GetRecurrenceL(

   545             orginalRecurrence,

   546             orginalUntil);

   547     CleanupStack::PopAndDestroy( recHandler );

   548     recHandler = NULL;

   549 

   550     TBool modifyingEntry( ESMREntryHelper::IsModifyingEntryL( *iEntry ) );

   551 

   552     if ( MESMRCalEntry::EESMRAllInSeries == aRule &&

   553          IsStoredL() && !IsForwardedL() && !IsOpenedFromMail() && !aTypeChanging )

   554         {

   555         // When we want to modify series of recurrence entries -->

   556         // Parent entry is modified

   557         if ( ERecurrenceNot == orginalRecurrence && !modifyingEntry )

   558             {

   559             // Orginal entry was not recurrent event

   560             // No need to fect instance at all

   561             // For modifying entries we need to fetch the original parent entry

   562             iRecurrenceModRule = aRule;

   563             return;

   564             }

   565 

   566         CCalInstance* instance = NULL;

   567         TRAPD(err, instance = InstanceL() );

   568         if( KErrNotFound != err )

   569             {

   570             User::LeaveIfError( err );

   571             }

   572 

   573         if ( instance )

   574             {

   575             CleanupStack::PushL( instance );

   576 

   577             CCalEntry::TMethod entryMethod( iEntry->MethodL() );

   578 

   579             delete iEntry;

   580             iEntry = NULL;

   581 

   582             delete iForwardEntry;

   583             iForwardEntry = NULL;

   584 

   585             delete iOrginalEntry;

   586             iOrginalEntry = NULL;

   587 

   588             RCPointerArray<CCalEntry> entries;

   589             CleanupClosePushL( entries );

   590 

   591             iCalDb.EntryViewL( instance->Entry() )->FetchL(

   592                     instance->Entry().UidL(), entries );

   593 

   594             TInt parentIndex( KErrNotFound );

   595             TInt entryCount( entries.Count() );

   596             for ( TInt i(0); i < entryCount && KErrNotFound == parentIndex; ++i )

   597                 {

   598                 TBool modifyingEntry( ESMREntryHelper::IsModifyingEntryL( *entries[i]) );

   599                 if ( !modifyingEntry )

   600                     {

   601                     parentIndex = i;

   602                     }

   603                 }

   604 

   605             __ASSERT_DEBUG( KErrNotFound != parentIndex, Panic(EESMRParentNotFound) );

   606 

   607             CCalEntry& parent = *entries[parentIndex];

   608 

   609             TPtrC description( parent.DescriptionL() );

   610 

   611             iEntry = CopyEntryL( iMRMailboxUtils, parent );

   612 

   613             // Adjust parent entry's start and end time to entry

   614             TCalTime start;

   615             TCalTime end;

   616 

   617             CESMRRecurrenceInfoHandler* recurrenceHandler =

   618                     CESMRRecurrenceInfoHandler::NewLC( parent );

   619 

   620             recurrenceHandler->GetFirstInstanceTimeL( start, end );

   621             CleanupStack::PopAndDestroy( recurrenceHandler );

   622             recurrenceHandler = NULL;

   623 

   624             iEntry->SetStartAndEndTimeL( start, end );

   625 

   626             iOrginalEntry = CopyEntryL( iMRMailboxUtils, *iEntry );

   627 

   628             if ( iEntry->MethodL() != entryMethod )

   629                 {

   630                 iEntry->SetMethodL( entryMethod );

   631                 iOrginalEntry->SetMethodL( entryMethod );

   632                 }

   633 

   634             iEntry->SetDescriptionL( description );

   635             iOrginalEntry->SetDescriptionL( description );

   636 

   637             CleanupStack::PopAndDestroy(); // entries

   638             CleanupStack::PopAndDestroy( instance );

   639 

   640             if ( EESMRRoleOrganizer == RoleL() && IsStoredL() )

   641                 {

   642                 // Increase sequence number

   643                 TInt seqNo( iEntry->SequenceNumberL() + 1);

   644                 iEntry->SetSequenceNumberL( seqNo );

   645                 iOrginalEntry->SetSequenceNumberL( seqNo );

   646                 }

   647             }

   648         }

   649     else if ( ERecurrenceNot != orginalRecurrence &&

   650     		aTypeChanging && !modifyingEntry )

   651     	{

   652 		// if entry( in the memory) is a recurrent event

   653 		// ,and if entry type is changing, and not in modifying status then EESMRAllInSeries

   654 		iRecurrenceModRule = EESMRAllInSeries ;

   655 		return;

   656     	}

   657 

   658     iRecurrenceModRule = aRule;

   659 

   660     }

   661 

   662 // ---------------------------------------------------------------------------

   663 // CESMRMeetingRequestEntry::SetAllDayEventL

   664 //

   665 // ---------------------------------------------------------------------------

   666 //

   667 void CESMRMeetingRequestEntry::SetAllDayEventL(

   668         TTime aStartDate,

   669         TTime aEndDate )

   670     {

   671     FUNC_LOG;

   672 

   673     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   674 

   675     TCalTime startTime;

   676     TCalTime stopTime;

   677 

   678     TDateTime start;

   679     TDateTime end;

   680 

   681     // set the start time to 0:00

   682     start.Set( aStartDate.DateTime().Year(),

   683                aStartDate.DateTime().Month(),

   684                aStartDate.DateTime().Day(),

   685                0,

   686                0,

   687                0,

   688                0);

   689 

   690     // set the end date to next day from given end date since

   691     // all day event should last 24 hours.

   692     TTime endDate = aEndDate + TTimeIntervalDays( 1 );

   693     end.Set( endDate.DateTime().Year(),

   694              endDate.DateTime().Month(),

   695              endDate.DateTime().Day(),

   696              0,

   697              0,

   698              0,

   699              0 );

   700 

   701     startTime.SetTimeLocalL( start );

   702     stopTime.SetTimeLocalL( end );

   703 

   704     iEntry->SetStartAndEndTimeL( startTime, stopTime );

   705 

   706     }

   707 

   708 // ---------------------------------------------------------------------------

   709 // CESMRMeetingRequestEntry::IsAllDayEventL

   710 //

   711 // ---------------------------------------------------------------------------

   712 //

   713 TBool CESMRMeetingRequestEntry::IsAllDayEventL() const

   714     {

   715     FUNC_LOG;

   716 

   717     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   718 

   719     CESMRCalUserUtil* entryUtil = CESMRCalUserUtil::NewLC( *iEntry );

   720 

   721     TBool allDayEvent( entryUtil->IsAlldayEventL() );

   722 

   723     CleanupStack::PopAndDestroy( entryUtil );

   724 

   725     return allDayEvent;

   726     }

   727 

   728 // ---------------------------------------------------------------------------

   729 // CESMRMeetingRequestEntry::IsStoredL

   730 // ---------------------------------------------------------------------------

   731 //

   732 TBool CESMRMeetingRequestEntry::IsStoredL() const

   733     {

   734     FUNC_LOG;

   735 

   736     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   737 

   738     TBool ret(EFalse);

   739     CCalEntry* dbEntry = NULL;

   740 

   741     TRAPD( err, dbEntry = iCalDb.FetchEntryL(

   742                                 iEntry->UidL(),

   743                                 iEntry->RecurrenceIdL() ) );

   744 

   745     if ( KErrNotFound == err )

   746         {

   747         // Error has occured while retrieving an entry

   748         ret = EFalse;

   749         }

   750     else if ( dbEntry)

   751         {

   752         // Entry was found from the calendar db --> it is stored for sure.

   753         ret = ETrue;

   754         }

   755 

   756     delete dbEntry;

   757 

   758 

   759     return ret;

   760     }

   761 

   762 // ---------------------------------------------------------------------------

   763 // CESMRMeetingRequestEntry::IsSentL

   764 // ---------------------------------------------------------------------------

   765 //

   766 TBool CESMRMeetingRequestEntry::IsSentL() const

   767     {

   768     FUNC_LOG;

   769 

   770     __ASSERT_DEBUG( iOrginalEntry, Panic(EESMREntryNotExist ) );

   771 

   772     TBool retVal( EFalse );

   773 

   774     if ( EESMRRoleOrganizer == RoleL()  )

   775         {

   776         CCalEntry::TStatus status( iOrginalEntry->StatusL() );

   777         if ( CCalEntry::ENullStatus != status )

   778             { // When we send a request for the first time we set

   779               // it's status to some other value than ENullStatus

   780             retVal = ETrue;

   781             }

   782         }

   783     else

   784         {

   785         // In attendee mode, we have sent the entry, if it is stored to

   786         // calendar db and status is known and not declined.

   787         // Declined entries are not stored to calendar db.

   788         TESMRAttendeeStatus currentStatus( AttendeeStatusL() );

   789         if ( IsStoredL()

   790              && EESMRAttendeeStatusUnknown != currentStatus

   791              && EESMRAttendeeStatusDecline != currentStatus )

   792             {

   793             retVal = ETrue;

   794             }

   795         }

   796 

   797 

   798     return retVal;

   799     }

   800 

   801 // ---------------------------------------------------------------------------

   802 // CESMRMeetingRequestEntry::IsEntryEditedL

   803 //

   804 // ---------------------------------------------------------------------------

   805 //

   806 TBool CESMRMeetingRequestEntry::IsEntryEditedL() const

   807     {

   808     FUNC_LOG;

   809 

   810     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   811     __ASSERT_DEBUG( iOrginalEntry, Panic(EESMREntryNotExist ) );

   812 

   813     TBool edited( EFalse );

   814 

   815     if ( iOrginalEntry )

   816         { // edited if differs from the db entry

   817         edited = !( iEntry->CompareL( *iOrginalEntry ) );

   818 

   819         TESMRRole role( RoleL() );

   820         if ( !edited && EESMRRoleOrganizer != role )

   821             {

   822             // CCalEntry::CompareL does not compare attedee statuses

   823             CCalAttendee* dbAttendee =

   824                     iMRMailboxUtils.ThisAttendeeL( *iOrginalEntry );

   825 

   826             CCalAttendee* me =

   827                     iMRMailboxUtils.ThisAttendeeL( *iEntry );

   828 

   829             if ( dbAttendee &&  me )

   830                 {

   831                 edited = dbAttendee->StatusL() != me->StatusL();

   832                 }

   833             }

   834         if ( !edited && EESMRRoleOrganizer == role &&

   835               iEntry->MethodL() != iOrginalEntry->MethodL() )

   836             {

   837             // For organizer CCalEntry::Compare does not compare entry's

   838             // method at all --> Need to compare ourselves.

   839             edited = ETrue;

   840             }

   841 

   842         // CCalEntry's CompareL doesn't check the priority value:

   843         if ( iOrginalEntry->PriorityL() != iEntry->PriorityL() )

   844             {

   845             edited = ETrue;

   846             }

   847 

   848         TPtrC description( iEntry->DescriptionL() );

   849         if ( description.CompareF( iOrginalEntry->DescriptionL() ) )

   850             {

   851             edited = ETrue;

   852             }

   853 

   854         TPtrC location( iEntry->LocationL() );

   855         if ( location.CompareF( iOrginalEntry->LocationL() ) )

   856             {

   857             edited = ETrue;

   858             }

   859 

   860         if( IsStoredL() )

   861             {

   862             if ( iCalDb.EntryViewL( *iEntry ) != iCalDb.EntryView() )

   863                 {

   864                 edited = ETrue;

   865                 }

   866             }

   867         }

   868 

   869 

   870 

   871     return edited;

   872     }

   873 

   874 // ---------------------------------------------------------------------------

   875 // CESMRMeetingRequestEntry::IsEntryTypeChangedL

   876 // ---------------------------------------------------------------------------

   877 //

   878 TBool CESMRMeetingRequestEntry::IsEntryTypeChangedL() const

   879     {

   880     FUNC_LOG;

   881 

   882     return iTypeChanged;

   883     }

   884 

   885 // ---------------------------------------------------------------------------

   886 // CESMRMeetingRequestEntry::GetAlarmL

   887 // ---------------------------------------------------------------------------

   888 //

   889 void CESMRMeetingRequestEntry::GetAlarmL(

   890         MESMRCalEntry::TESMRAlarmType& aAlarmType,

   891         TTime &aAlarmTime )

   892     {

   893     FUNC_LOG;

   894 

   895     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   896 

   897     aAlarmType = MESMRCalEntry::EESMRAlarmNotFound;

   898     aAlarmTime = Time::NullTTime();

   899 

   900     TFileName alarmInfoResource;

   901     ESMRHelper::LocateResourceFile(

   902             KAlarmInfoResource,

   903             KDC_RESOURCE_FILES_DIR,

   904             alarmInfoResource);

   905 

   906 

   907     CESMRAlarmInfoHandler* alarmInfoHandler =

   908             CESMRAlarmInfoHandler::NewLC();

   909 

   910     alarmInfoHandler->ReadFromResourceL(

   911             alarmInfoResource,

   912             ESRM_ALARM_INFO_TABLE );

   913 

   914     TRAPD( err,

   915             alarmInfoHandler->GetAbsoluteAlarmTimeL(*iEntry, aAlarmTime) );

   916 

   917     if ( KErrNone == err )

   918         {

   919         aAlarmType = MESMRCalEntry::EESMRAlarmAbsolute;

   920 

   921         // only meeting request that is not allday event can have

   922         // relative alarm:

   923         if ( !IsAllDayEventL() )

   924             {

   925             TESMRAlarmInfo alarmInfo;

   926             TRAP( err,

   927                   alarmInfoHandler->GetAlarmInfoObjectL(*iEntry, alarmInfo) );

   928 

   929             if ( KErrNone == err )

   930                 {

   931                 aAlarmType = MESMRCalEntry::EESMRAlarmRelative;

   932                 if( alarmInfo.iRelativeAlarmInSeconds < 0 )

   933                     {

   934                     aAlarmType = MESMRCalEntry::EESMRAlarmNotFound;

   935                     }

   936                 }

   937             }

   938         }

   939 

   940     CleanupStack::PopAndDestroy( alarmInfoHandler );

   941 

   942     }

   943 

   944 

   945 // ---------------------------------------------------------------------------

   946 // CESMRMeetingRequestEntry::OriginalEntry

   947 // ---------------------------------------------------------------------------

   948 //

   949 const CCalEntry& CESMRMeetingRequestEntry::OriginalEntry()

   950     {

   951     FUNC_LOG;

   952     return *iOrginalEntry;

   953     }

   954 

   955 

   956 // ---------------------------------------------------------------------------

   957 // CESMRMeetingRequestEntry::UpdateEntryAfterStoringL

   958 // ---------------------------------------------------------------------------

   959 //

   960 void CESMRMeetingRequestEntry::UpdateEntryAfterStoringL()

   961     {

   962     FUNC_LOG;

   963 

   964     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   965 

   966     CCalEntry* storedEntry = NULL;

   967 

   968 

   969     if ( IsRecurrentEventL() &&

   970          EESMRThisOnly == iRecurrenceModRule &&

   971          !IsForwardedL() && IsStoredL() &&

   972          !ESMREntryHelper::IsModifyingEntryL(*iEntry) )

   973         {

   974         // We have stored one instance of series.

   975         storedEntry = iCalDb.FetchEntryL(

   976                     iEntry->UidL(),

   977                     iOrginalEntry->StartTimeL() );

   978         }

   979     else

   980         {

   981         // We are dealing with single instance or with the series

   982         storedEntry = iCalDb.FetchEntryL(

   983                     iEntry->UidL(),

   984                     iEntry->RecurrenceIdL() );

   985         }

   986 

   987 

   988     __ASSERT_DEBUG( storedEntry, Panic( EESMREntryNotExist ) );

   989     CleanupStack::PushL( storedEntry );

   990 

   991     // Description needs to be fecthed explicitly into memory

   992     TPtrC description( storedEntry->DescriptionL() );

   993 

   994 

   995     delete iEntry;

   996     iEntry = NULL;

   997     iEntry = CopyEntryL( iMRMailboxUtils, *storedEntry );

   998 

   999     if ( MESMRCalEntry::EESMRAllInSeries == iRecurrenceModRule &&

  1000          IsRecurrentEventL() )

  1001         {

  1002         // Adjust parent entry's start and end time to entry

  1003         TCalTime start;

  1004         TCalTime end;

  1005 

  1006         CESMRRecurrenceInfoHandler* recurrenceHandler =

  1007                 CESMRRecurrenceInfoHandler::NewLC( *iEntry );

  1008 

  1009         recurrenceHandler->GetFirstInstanceTimeL( start, end );

  1010         CleanupStack::PopAndDestroy( recurrenceHandler );

  1011         recurrenceHandler = NULL;

  1012 

  1013         iEntry->SetStartAndEndTimeL( start, end );

  1014         iEntry->SetDescriptionL( description );

  1015         }

  1016 

  1017     CCalEntry* temp  = CopyEntryL( iMRMailboxUtils, *iEntry );

  1018 

  1019     delete iOrginalEntry;

  1020     iOrginalEntry = temp;

  1021 

  1022     CleanupStack::PopAndDestroy( storedEntry );

  1023     }

  1024 

  1025 // ----------------------------------------------------------------------------

  1026 // CMRCalEntry::UpdateComparativeEntry

  1027 // ----------------------------------------------------------------------------

  1028 //

  1029 void CESMRMeetingRequestEntry::UpdateComparativeEntry(

  1030         CCalEntry* aNewComparativeEntry )

  1031     {

  1032     FUNC_LOG;

  1033 

  1034     if( iOrginalEntry ) // Update comparative entry

  1035         {

  1036         delete iOrginalEntry;

  1037         iOrginalEntry = NULL;

  1038 

  1039         iOrginalEntry = aNewComparativeEntry;

  1040         }

  1041 

  1042     }

  1043 

  1044 // ---------------------------------------------------------------------------

  1045 // CESMRMeetingRequestEntry::SetDefaultValuesToEntryL

  1046 // ---------------------------------------------------------------------------

  1047 //

  1048 void CESMRMeetingRequestEntry::SetDefaultValuesToEntryL()

  1049     {

  1050     FUNC_LOG;

  1051 

  1052     if ( !IsStoredL() )

  1053         {

  1054         SetPriorityL( EFSCalenMRPriorityNormal );

  1055 

  1056         // Get default alarm time from central repository

  1057         TInt defaultAlarmTime=0;

  1058         CRepository* repository = CRepository::NewLC( KCRUidCalendar );

  1059 

  1060         TInt err = KErrNotFound;

  1061 

  1062         if ( repository )

  1063             {

  1064             err = repository->Get(

  1065                     KCalendarDefaultAlarmTime,

  1066                     defaultAlarmTime );

  1067             CleanupStack::PopAndDestroy( repository );

  1068             }

  1069 

  1070         if ( err != KErrNone )

  1071             {

  1072             // By default 15 minutes if not found from central repository

  1073             defaultAlarmTime = KDefaultMeetingAlarmMinutes;

  1074             }

  1075 

  1076         // Getting current time

  1077         TTime currentTime;

  1078         currentTime.HomeTime();

  1079 

  1080         // Getting meeting start time

  1081         TTime start = iEntry->StartTimeL().TimeLocalL();

  1082 

  1083         // Create default alarm

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

  1085         CleanupStack::PushL( alarm );

  1086 

  1087         TTimeIntervalMinutes alarmOffset( defaultAlarmTime );

  1088 

  1089         // If alarm time is in past

  1090         if ( ( start - alarmOffset ) < currentTime )

  1091             {

  1092             // Setting alarm off

  1093             iEntry->SetAlarmL( NULL );

  1094             }

  1095         else

  1096             {

  1097             // Set default alarm time

  1098             alarm->SetTimeOffset( alarmOffset );

  1099             iEntry->SetAlarmL( alarm );

  1100             }

  1101         CleanupStack::PopAndDestroy( alarm );

  1102         }

  1103 

  1104     // Set the default end time if not set by client

  1105     if ( iEntry->StartTimeL().TimeUtcL() == iEntry->EndTimeL().TimeUtcL() )

  1106         {

  1107         // This value might also be read from cenrep

  1108         TTimeIntervalHours KDefaultMeetingDuration(1);

  1109 

  1110         TCalTime newEndTime;

  1111         newEndTime.SetTimeUtcL(

  1112                 iEntry->StartTimeL().TimeUtcL() + KDefaultMeetingDuration );

  1113         iEntry->SetStartAndEndTimeL(iEntry->StartTimeL(), newEndTime);

  1114         }

  1115 

  1116     iEntry->SetReplicationStatusL( CCalEntry::EOpen );

  1117 

  1118     //Original entry must be stored after the default values are set.

  1119     //Otherwise it looks like settings are changed even though they haven't

  1120     CCalEntry* temp = CopyEntryL( iMRMailboxUtils, *iEntry );

  1121 

  1122     delete iOrginalEntry;

  1123     iOrginalEntry = temp;

  1124     }

  1125 

  1126 // ---------------------------------------------------------------------------

  1127 // CESMRMeetingRequestEntry::CloneEntryLC

  1128 // ---------------------------------------------------------------------------

  1129 //

  1130 CCalEntry* CESMRMeetingRequestEntry::CloneEntryLC(

  1131         TESMRCalEntryType aType ) const

  1132     {

  1133     CCalEntry* entry =

  1134         ESMRHelper::CopyEntryLC( *iEntry,

  1135                                  iEntry->MethodL(),