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 //<cmail>

    21 #include "emailtrace.h"

    22 #include "cesmralarminfohandler.h"

    23 #include "cesmrrecurrenceinfohandler.h"

    24 //</cmail>

    25 #include <centralrepository.h>

    26 #include <calalarm.h>

    27 

    28 #include "cesmrmeetingrequestentry.h"

    29 #include "cesmrfsmailboxutils.h"

    30 #include "cesmrcaldbmgr.h"

    31 #include "esmrhelper.h"

    32 #include "esmrentryhelper.h"

    33 #include "cesmrconflictchecker.h"

    34 #include "cesmrcaluserutil.h"

    35 #include "esmrconfig.hrh"

    36 

    37 #include <esmralarminfo.rsg>

    38 #include <calentry.h>

    39 #include <calinstance.h>

    40 #include <calinstanceview.h>

    41 #include <caluser.h>

    42 #include <CalenInterimUtils2.h>

    43 #include <cmrmailboxutils.h>

    44 #include <calrrule.h>

    45 //<cmail>

    46 #include "mmrinfoobject.h"

    47 #include "mmrattendee.h"

    48 //</cmail>

    49 #include <CalendarInternalCRKeys.h>

    50 #include <data_caging_path_literals.hrh>

    51 #include <coemain.h>

    52 #include <calentryview.h>

    53 #include <ct/rcpointerarray.h>

    54 

    55 /// Unnamed namespace for local definitions

    56 namespace {

    57 

    58 // Alarm resource file location

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

    60 

    61 // Definition for first index

    62 const TInt KFirstIndex = 0;

    63 

    64 // Definition for 0

    65 const TInt KZero = 0;

    66 

    67 // Definition for 1

    68 const TInt KOne = 1;

    69 

    70 // Definition for number of hours within day

    71 const TInt KHoursInDay = 24;

    72 

    73 // Definition for default alarm time for meeting

    74 const TInt KDefaultMeetingAlarmMinutes( 15 );

    75 

    76 _LIT( KReplaceLineFeedChar, "\n" );

    77 _LIT( KLineFeed, "\x2029");

    78 

    79 /**

    80  * Finds matching calendar instance from calendar db. Ownership is

    81  * transferred, If instance cannot be found, NULL is returned.

    82  *

    83  * @param aCalDb Reference to cal db manager.

    84  * @param aEntry Reference to calendar entry

    85  * @return Pointer to calendar entry instance.

    86  */

    87 CCalInstance* FindInstanceL(

    88         MESMRCalDbMgr& aCalDb,

    89         CCalEntry& aEntry )

    90     {

    91     CCalInstance* instance = NULL;

    92     RCPointerArray<CCalInstance> calInstances;

    93     CleanupClosePushL( calInstances );

    94 

    95     CCalInstanceView* instanceView =

    96             aCalDb.NormalDbInstanceView();

    97 

    98     CalCommon::TCalViewFilter instanceFilter =

    99             CalCommon::EIncludeAppts |

   100             CalCommon::EIncludeEvents;

   101 

   102     // Removing one seconds from start time and adding one second to stop

   103     // time. Otherwise wanted entry is not included into results.

   104     TCalTime startTime;

   105     startTime.SetTimeLocalL(

   106         aEntry.StartTimeL().TimeLocalL() - TTimeIntervalSeconds(KOne) );

   107     TCalTime endTime;

   108     endTime.SetTimeLocalL(

   109         aEntry.EndTimeL().TimeLocalL() + TTimeIntervalSeconds(KOne) );

   110 

   111     TDateTime start = startTime.TimeLocalL().DateTime();

   112     TDateTime end   = endTime.TimeLocalL().DateTime();

   113 

   114     CalCommon::TCalTimeRange timeRange(

   115             startTime,

   116             endTime );

   117 

   118     instanceView->FindInstanceL(

   119             calInstances,

   120             instanceFilter,

   121             timeRange);

   122 

   123     TInt instanceCount( calInstances.Count() );

   124     for (TInt i = 0; (i < instanceCount && !instance); ++i)

   125         {

   126         CCalEntry& entry = calInstances[i]->Entry();

   127 

   128         // Finding the entry we are intrested for

   129         if ( !entry.UidL().Compare( aEntry.UidL() ) )

   130             {

   131             instance = calInstances[i];

   132             calInstances.Remove( i );

   133             }

   134         }

   135     CleanupStack::PopAndDestroy(); // arrayCleanup

   136     return instance;

   137     }

   138 

   139 #ifdef _DEBUG

   140 

   141 // Definition for panic text

   142 _LIT( KESMREntryPanicTxt, "ESMRMeetingRequestEntry" );

   143 

   144 /**

   145  * ES MR Entry panic codes

   146  */

   147 enum TESMRMeetingRequestEntry

   148     {

   149     EESMREntryNotExist = 1, // Entry does not exist

   150     EESMRInvalidRole,       // Phone owner has invalid role

   151     EESMRNoInfoObjectAttendeeFound,

   152     EESMRPhoneOwnerNotSet,

   153     EESMRRecurrenceError,

   154     EESMRInvalidReplyType,

   155     EESMRInvalidInvalidAttendeeStatus,

   156     EESMRParentNotFound

   157     };

   158 

   159 /**

   160  * Raises panic.

   161  * @param aPanic Panic code

   162  */

   163 void Panic(TESMRMeetingRequestEntry aPanic)

   164     {

   165     User::Panic( KESMREntryPanicTxt, aPanic);

   166     }

   167 

   168 #endif // _DEBUG

   169 

   170 }  // namespace

   171 

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

   173 

   174 // ---------------------------------------------------------------------------

   175 // CESMRMeetingRequestEntry::CESMRMeetingRequestEntry

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

   177 //

   178 inline CESMRMeetingRequestEntry::CESMRMeetingRequestEntry(

   179         CMRMailboxUtils& aMRMailboxUtils,

   180         MESMRCalDbMgr& aCalDb,

   181         TBool aConflictsExists,

   182         TESMRInputParams* aESMRInputParams )

   183 :   iMRMailboxUtils( aMRMailboxUtils ),

   184     iConflictsExists( aConflictsExists),

   185     iCalDb( aCalDb ),

   186     iESMRInputParams( aESMRInputParams )

   187     {

   188     FUNC_LOG;

   189     // Not yet implementation

   190     }

   191 

   192 // ---------------------------------------------------------------------------

   193 // CESMRMeetingRequestEntry::~CESMRMeetingRequestEntry

   194 // ---------------------------------------------------------------------------

   195 //

   196 CESMRMeetingRequestEntry::~CESMRMeetingRequestEntry()

   197     {

   198     FUNC_LOG;

   199     delete iEntry;

   200     delete iForwardEntry;

   201     delete iOrginalEntry;

   202     delete iParameterEntry;

   203     }

   204 

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

   206 // CESMRMeetingRequestEntry::NewL

   207 // ---------------------------------------------------------------------------

   208 //

   209 CESMRMeetingRequestEntry* CESMRMeetingRequestEntry::NewL(

   210         const CCalEntry& aEntry,

   211         CMRMailboxUtils& aMRMailboxUtils,

   212         MESMRCalDbMgr& aCalDb,

   213         TBool aConflictsExists,

   214         TESMRInputParams* aESMRInputParams )

   215     {

   216     FUNC_LOG;

   217 

   218     CESMRMeetingRequestEntry* self =

   219             new (ELeave) CESMRMeetingRequestEntry(

   220                 aMRMailboxUtils,

   221                 aCalDb,

   222                 aConflictsExists,

   223                 aESMRInputParams );

   224 

   225     CleanupStack::PushL( self );

   226     self->ConstructL( aEntry );

   227     CleanupStack::Pop( self );

   228 

   229     return self;

   230     }

   231 

   232 // ---------------------------------------------------------------------------

   233 // CESMRMeetingRequestEntry::ConstructL

   234 // ---------------------------------------------------------------------------

   235 //

   236 void CESMRMeetingRequestEntry::ConstructL(

   237         const CCalEntry& aEntry )

   238     {

   239     FUNC_LOG;

   240     

   241     iParameterEntry = ESMRHelper::CopyEntryL(

   242         aEntry,

   243         aEntry.MethodL(),

   244         ESMRHelper::ECopyFull );    

   245     

   246     iEntry = ESMRHelper::CopyEntryL(

   247         aEntry,

   248         aEntry.MethodL(),

   249         ESMRHelper::ECopyFull );

   250 

   251     if ( !IsStoredL() && !IsOpenedFromMail() )

   252         {

   253         // by default when creating a meeting the priority value is normal

   254         SetPriorityL( EFSCalenMRPriorityNormal );

   255         }

   256 

   257     iOrginalEntry  = ESMRHelper::CopyEntryL(

   258         aEntry,

   259         aEntry.MethodL(),

   260         ESMRHelper::ECopyFull );

   261     

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

   263         {

   264         // Increase sequence number

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

   266         iEntry->SetSequenceNumberL( seqNo );

   267         iOrginalEntry->SetSequenceNumberL( seqNo );

   268         }

   269 

   270 

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

   272 

   273     if ( CCalEntry::EMethodNone == method )

   274         {

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

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

   277         }

   278 

   279     HBufC* newDescription = ReplaceCharactersFromBufferLC(

   280                                     iEntry->DescriptionL(),       

   281                                     KReplaceLineFeedChar(),

   282                                     KLineFeed() );

   283     iEntry->SetDescriptionL( *newDescription );

   284     CleanupStack::PopAndDestroy( newDescription );

   285         

   286     }

   287 

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

   289 // CESMRMeetingRequestEntry::ReplaceCharactersFromBufferL

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

   291 //

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

   293                               const TDesC& aFindString, 

   294                               const TDesC& aReplacement )

   295     {

   296     FUNC_LOG;

   297     HBufC* newBuffer = aTarget.AllocLC();

   298     TPtr16 ptr = newBuffer->Des();

   299     

   300     // find next occurance:

   301     TInt offset = ptr.Find(aFindString);

   302     while ( offset != KErrNotFound )

   303         {

   304         // replace the data:

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

   306         

   307         // find next occurance:

   308         offset = ptr.Find(aFindString);

   309         }

   310     

   311     return newBuffer;

   312     }         

   313 

   314 // ---------------------------------------------------------------------------

   315 // CESMRMeetingRequestEntry::Type

   316 // ---------------------------------------------------------------------------

   317 //

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

   319     {

   320     FUNC_LOG;

   321     // This is meeting request

   322     return MESMRCalEntry::EESMRCalEntryMeetingRequest;

   323     }

   324 

   325 // ---------------------------------------------------------------------------

   326 // CESMRMeetingRequestEntry::MESMRCalEntryRef

   327 // ---------------------------------------------------------------------------

   328 //

   329 MESMRCalEntry& CESMRMeetingRequestEntry::MESMRCalEntryRef()

   330     {

   331     FUNC_LOG;

   332     return *this;

   333     }

   334 

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

   336 // CESMRMeetingRequestEntry::MESMRCalEntryRef

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

   338 //

   339 const MESMRCalEntry& CESMRMeetingRequestEntry::MESMRCalEntryRef() const

   340     {

   341     FUNC_LOG;

   342     return *this;

   343     }

   344 // ---------------------------------------------------------------------------

   345 // CESMRMeetingRequestEntry::Entry

   346 // ---------------------------------------------------------------------------

   347 //

   348 CCalEntry& CESMRMeetingRequestEntry::Entry()

   349     {

   350     FUNC_LOG;

   351     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   352 

   353     if ( iForwardEntry )

   354         {

   355         return *iForwardEntry;

   356         }

   357 

   358     return *iEntry;

   359     }

   360 

   361 // ---------------------------------------------------------------------------

   362 // CESMRMeetingRequestEntry::Entry

   363 // ---------------------------------------------------------------------------

   364 //

   365 const CCalEntry& CESMRMeetingRequestEntry::Entry() const

   366     {

   367     FUNC_LOG;

   368     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   369     if ( iForwardEntry )

   370         {

   371         return *iForwardEntry;

   372         }

   373     return *iEntry;

   374     }

   375 

   376 // ---------------------------------------------------------------------------

   377 // CESMRMeetingRequestEntry::InstanceL

   378 // ---------------------------------------------------------------------------

   379 //

   380 CCalInstance* CESMRMeetingRequestEntry::InstanceL() const

   381     {

   382     FUNC_LOG;

   383 

   384     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   385     __ASSERT_DEBUG( iOrginalEntry, Panic(EESMREntryNotExist ) );

   386 

   387     CCalInstance* instance = NULL;

   388 

   389     instance = FindInstanceL( iCalDb, *iEntry );

   390     if ( !instance )

   391         {

   392         // Instance not found by using the edited entry

   393         // Trying with orginal.

   394         instance = FindInstanceL( iCalDb, *iOrginalEntry );

   395         }

   396 

   397     if ( !instance )

   398         {

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

   400         // --> Leave

   401 

   402 

   403         User::Leave( KErrNotFound );

   404         }

   405 

   406 

   407     return instance;

   408     }

   409 

   410 // ---------------------------------------------------------------------------

   411 // CESMRMeetingRequestEntry::CanSetRecurrenceL

   412 // ---------------------------------------------------------------------------

   413 //

   414 TBool CESMRMeetingRequestEntry::CanSetRecurrenceL() const

   415     {

   416     FUNC_LOG;

   417 

   418     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   419 

   420     TBool canSetRecurrence( ETrue );

   421 

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

   423             ESMREntryHelper::IsRepeatingMeetingL(*iEntry) &&

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

   425           MESMRCalEntry::EESMRThisOnly == iRecurrenceModRule ))

   426         {

   427         canSetRecurrence = EFalse;

   428         }

   429 

   430 

   431     return canSetRecurrence;

   432     }

   433 

   434 // ---------------------------------------------------------------------------

   435 // CESMRMeetingRequestEntry::IsRecurrentEventL

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

   437 //

   438 TBool CESMRMeetingRequestEntry::IsRecurrentEventL() const

   439     {

   440     FUNC_LOG;

   441 

   442     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   443 

   444     TBool recurrenceEvent( EFalse );

   445     if ( IsStoredL() )

   446         {

   447         // Entry is stored in calendar db

   448         // Lets look recurrence using instance

   449 

   450         // Ownership is transferred

   451         CCalInstance* instance = NULL;

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

   453         if ( KErrNotFound != err )

   454             {

   455             User::LeaveIfError( err );

   456             }

   457 

   458         if ( instance )

   459             {

   460             CleanupStack::PushL( instance );

   461 

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

   463 

   464             if ( ESMREntryHelper::IsRepeatingMeetingL( instanceParentEntry ) )

   465                 {

   466                 recurrenceEvent = ETrue;

   467                 }

   468             CleanupStack::PopAndDestroy( instance );

   469             }

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

   471             {

   472             recurrenceEvent = ETrue;

   473             }

   474         }

   475     else

   476         {

   477         // Entry is not stored in calendar db

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

   479             {

   480             // This is repeating meeting

   481             recurrenceEvent = ETrue;

   482             }

   483         }

   484 

   485 

   486     return recurrenceEvent;

   487     }

   488 

   489 // ---------------------------------------------------------------------------

   490 // CESMRMeetingRequestEntry::SetRecurrenceL

   491 //

   492 // ---------------------------------------------------------------------------

   493 //

   494 void CESMRMeetingRequestEntry::SetRecurrenceL(

   495         TESMRRecurrenceValue aRecurrence,

   496         TTime aUntil )

   497     {

   498     FUNC_LOG;

   499 

   500     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   501 

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

   503     if ( !CanSetRecurrenceL() )

   504         {

   505         User::Leave( KErrNotSupported );

   506         }

   507 

   508     if ( aRecurrence != ERecurrenceNot &&

   509             MESMRCalEntry::EESMRAllInSeries != iRecurrenceModRule )

   510         {

   511         // Make sure that mod rule is correct

   512         SetModifyingRuleL(

   513                 MESMRCalEntry::EESMRAllInSeries );

   514         }

   515 

   516     CESMRRecurrenceInfoHandler* recurrenceHandler =

   517             CESMRRecurrenceInfoHandler::NewLC( *iEntry );

   518 

   519     recurrenceHandler->SetRecurrenceL( aRecurrence, aUntil );

   520 

   521     CleanupStack::PopAndDestroy( recurrenceHandler );

   522 

   523     }

   524 

   525 // ---------------------------------------------------------------------------

   526 // CESMRMeetingRequestEntry::GetRecurrenceL

   527 //

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

   529 //

   530 void CESMRMeetingRequestEntry::GetRecurrenceL(

   531         TESMRRecurrenceValue& aRecurrence,

   532         TTime& aUntil) const

   533     {

   534     FUNC_LOG;

   535 

   536     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   537 

   538     CESMRRecurrenceInfoHandler* recurrenceHandler =

   539             CESMRRecurrenceInfoHandler::NewLC( *iEntry );

   540 

   541     recurrenceHandler->GetRecurrenceL( aRecurrence, aUntil );

   542     CleanupStack::PopAndDestroy( recurrenceHandler );

   543 

   544     }

   545 

   546 // ---------------------------------------------------------------------------

   547 // CESMRMeetingRequestEntry::RecurrenceModRule

   548 // ---------------------------------------------------------------------------

   549 //

   550 MESMRCalEntry::TESMRRecurrenceModifyingRule

   551     CESMRMeetingRequestEntry::RecurrenceModRule() const

   552     {

   553     return iRecurrenceModRule;

   554     }

   555 

   556 // ---------------------------------------------------------------------------

   557 // CESMRMeetingRequestEntry::SetModifyingRuleL

   558 // ---------------------------------------------------------------------------

   559 //

   560 void CESMRMeetingRequestEntry::SetModifyingRuleL(

   561         TESMRRecurrenceModifyingRule aRule )

   562     {

   563     FUNC_LOG;

   564 

   565     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   566 

   567     CESMRRecurrenceInfoHandler* recHandler =

   568             CESMRRecurrenceInfoHandler::NewL( *iOrginalEntry );

   569     CleanupStack::PushL( recHandler );

   570 

   571     TESMRRecurrenceValue orginalRecurrence;

   572     TTime orginalUntil;

   573 

   574     recHandler->GetRecurrenceL(

   575             orginalRecurrence,

   576             orginalUntil);

   577 

   578     CleanupStack::PopAndDestroy( recHandler );

   579     recHandler = NULL;

   580 

   581 

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

   583          IsStoredL() && !IsForwardedL() && !IsOpenedFromMail() )

   584         {

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

   586         // Parent entry is modified

   587 

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

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

   590             {

   591             // Orginal entry was not recurrent event

   592             // No need to fect instance at all

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

   594             iRecurrenceModRule = aRule;

   595             return;

   596             }

   597 

   598         CCalInstance* instance = NULL;

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

   600         if( KErrNotFound != err )

   601             {

   602             User::LeaveIfError( err );

   603             }

   604 

   605         if ( instance )

   606             {

   607             CleanupStack::PushL( instance );

   608 

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

   610            

   611             delete iEntry; 

   612             iEntry = NULL;

   613             

   614             delete iForwardEntry; 

   615             iForwardEntry = NULL;

   616             

   617             delete iOrginalEntry; 

   618             iOrginalEntry = NULL;

   619 

   620             RCPointerArray<CCalEntry> entries;

   621             CleanupClosePushL( entries );

   622 

   623             iCalDb.NormalDbEntryView()->FetchL(

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

   625 

   626             TInt parentIndex( KErrNotFound );

   627             TInt entryCount( entries.Count() );            

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

   629                 {

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

   631                 if ( !modifyingEntry )

   632                     {

   633                     parentIndex = i;

   634                     }

   635                 }

   636 

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

   638             

   639             CCalEntry& parent = *entries[parentIndex];

   640 

   641             TPtrC description( parent.DescriptionL() );

   642             

   643             iEntry = ESMRHelper::CopyEntryL(

   644                             parent,

   645                             parent.MethodL(),

   646                             ESMRHelper::ECopyFull );

   647             

   648             CESMRFsMailboxUtils* fsMbUtils = 

   649                     CESMRFsMailboxUtils::NewL( iMRMailboxUtils );

   650             CleanupStack::PushL( fsMbUtils );

   651             

   652             fsMbUtils->SetPhoneOwnerL( *iEntry );

   653             CleanupStack::PopAndDestroy( fsMbUtils );

   654             fsMbUtils = NULL;

   655             

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

   657             TCalTime start;

   658             TCalTime end;

   659 

   660             CESMRRecurrenceInfoHandler* recurrenceHandler =

   661                     CESMRRecurrenceInfoHandler::NewLC( parent );

   662 

   663             recurrenceHandler->GetFirstInstanceTimeL( start, end );

   664             CleanupStack::PopAndDestroy( recurrenceHandler );

   665             recurrenceHandler = NULL;

   666 

   667             iEntry->SetStartAndEndTimeL( start, end );

   668 

   669             iOrginalEntry = ESMRHelper::CopyEntryL(

   670                                     *iEntry,

   671                                     iEntry->MethodL(),

   672                                     ESMRHelper::ECopyFull );

   673 

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

   675                 {

   676                 iEntry->SetMethodL( entryMethod );

   677                 iOrginalEntry->SetMethodL( entryMethod );

   678                 }

   679 

   680             iEntry->SetDescriptionL( description );

   681             iOrginalEntry->SetDescriptionL( description );

   682             

   683             CleanupStack::PopAndDestroy(); // entries

   684             CleanupStack::PopAndDestroy( instance );

   685 

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

   687                 {

   688                 // Increase sequence number

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

   690                 iEntry->SetSequenceNumberL( seqNo );

   691                 iOrginalEntry->SetSequenceNumberL( seqNo );

   692                 }

   693             }

   694         }

   695 

   696     iRecurrenceModRule = aRule;

   697 

   698     }

   699 

   700 // ---------------------------------------------------------------------------

   701 // CESMRMeetingRequestEntry::SetAllDayEventL

   702 //

   703 // ---------------------------------------------------------------------------

   704 //

   705 void CESMRMeetingRequestEntry::SetAllDayEventL(

   706         TTime aStartDate,

   707         TTime aEndDate )

   708     {

   709     FUNC_LOG;

   710 

   711     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   712 

   713     TCalTime startTime;

   714     TCalTime stopTime;

   715 

   716     TDateTime start;

   717     TDateTime end;

   718 

   719     // set the start time to 0:00

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

   721                aStartDate.DateTime().Month(),

   722                aStartDate.DateTime().Day(),

   723                KZero,

   724                KZero,

   725                KZero,

   726                KZero);

   727 

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

   729     // all day event should last 24 hours.

   730     TTime endDate = aEndDate + TTimeIntervalDays( 1 );

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

   732              endDate.DateTime().Month(),

   733              endDate.DateTime().Day(),

   734              KZero,

   735              KZero,

   736              KZero,

   737              KZero );

   738 

   739     startTime.SetTimeLocalL( start );

   740     stopTime.SetTimeLocalL( end );

   741 

   742     iEntry->SetStartAndEndTimeL( startTime, stopTime );

   743 

   744     }

   745 

   746 // ---------------------------------------------------------------------------

   747 // CESMRMeetingRequestEntry::IsAllDayEventL

   748 //

   749 // ---------------------------------------------------------------------------

   750 //

   751 TBool CESMRMeetingRequestEntry::IsAllDayEventL() const

   752     {

   753     FUNC_LOG;

   754 

   755     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   756 

   757     TBool allDayEvent(EFalse);

   758 

   759     TCalTime startTime = iEntry->StartTimeL();

   760     TCalTime stopTime  = iEntry->EndTimeL();

   761 

   762     TTimeIntervalHours hoursBetweenStartAndEnd;

   763     stopTime.TimeLocalL().HoursFrom(

   764             startTime.TimeLocalL(),

   765             hoursBetweenStartAndEnd );

   766 

   767     TCalTime::TTimeMode mode = startTime.TimeMode();

   768 

   769     TInt hoursBetweenStartAndEndAsInt(  hoursBetweenStartAndEnd.Int() );

   770     TInt alldayDivident(  hoursBetweenStartAndEndAsInt % KHoursInDay );

   771 

   772     if ( hoursBetweenStartAndEndAsInt&& KZero == alldayDivident )

   773         {

   774         TDateTime startTimeLocal = startTime.TimeLocalL().DateTime();

   775         TDateTime stopTimeLocal =  stopTime.TimeLocalL().DateTime();

   776 

   777         if ( startTimeLocal.Hour() == stopTimeLocal.Hour() &&

   778              startTimeLocal.Minute() == stopTimeLocal.Minute() &&

   779              startTimeLocal.Second() == stopTimeLocal.Second() )

   780             {

   781             allDayEvent = ETrue;

   782             }

   783         }

   784 

   785 

   786     return allDayEvent;

   787     }

   788 

   789 // ---------------------------------------------------------------------------

   790 // CESMRMeetingRequestEntry::IsStoredL

   791 // ---------------------------------------------------------------------------

   792 //

   793 TBool CESMRMeetingRequestEntry::IsStoredL() const

   794     {

   795     FUNC_LOG;

   796 

   797     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   798 

   799     TBool ret(EFalse);

   800     CCalEntry* dbEntry = NULL;

   801     

   802     TRAPD( err, dbEntry = iCalDb.FetchEntryL(

   803                                 iEntry->UidL(),

   804                                 iEntry->RecurrenceIdL() ) );

   805     

   806     if ( KErrNotFound == err )

   807         {

   808         // Error has occured while retrieving an entry        

   809         ret = EFalse;

   810         }    

   811     else if ( dbEntry)

   812         {

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

   814         ret = ETrue;

   815         }

   816 

   817     delete dbEntry;

   818 

   819 

   820     return ret;

   821     }

   822 

   823 // ---------------------------------------------------------------------------

   824 // CESMRMeetingRequestEntry::IsSentL

   825 // ---------------------------------------------------------------------------

   826 //

   827 TBool CESMRMeetingRequestEntry::IsSentL() const

   828     {

   829     FUNC_LOG;

   830 

   831     __ASSERT_DEBUG( iOrginalEntry, Panic(EESMREntryNotExist ) );

   832 

   833     TBool retVal( EFalse );

   834 

   835     if ( EESMRRoleOrganizer == RoleL()  )

   836         {

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

   838         if ( CCalEntry::ENullStatus != status )

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

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

   841             retVal = ETrue;

   842             }

   843         }

   844     else

   845         {

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

   847         // calendar db and status is not declined. Declined entries are

   848         // not stored to calendar db.

   849         TESMRAttendeeStatus currentStatus( AttendeeStatusL() );

   850         if ( IsStoredL() && EESMRAttendeeStatusDecline != currentStatus)

   851             {

   852             retVal = ETrue;

   853             }

   854         }

   855 

   856 

   857     return retVal;

   858     }

   859 

   860 // ---------------------------------------------------------------------------

   861 // CESMRMeetingRequestEntry::IsEntryEditedL

   862 //

   863 // ---------------------------------------------------------------------------

   864 //

   865 TBool CESMRMeetingRequestEntry::IsEntryEditedL() const

   866     {

   867     FUNC_LOG;

   868 

   869     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   870     __ASSERT_DEBUG( iOrginalEntry, Panic(EESMREntryNotExist ) );

   871 

   872     TBool edited( EFalse );

   873 

   874     if ( iOrginalEntry )

   875         { // edited if differs from the db entry

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

   877 

   878         TESMRRole role( RoleL() );

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

   880             {

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

   882             CCalAttendee* dbAttendee =

   883                     iMRMailboxUtils.ThisAttendeeL( *iOrginalEntry );

   884 

   885             CCalAttendee* me =

   886                     iMRMailboxUtils.ThisAttendeeL( *iEntry );

   887 

   888             if ( dbAttendee &&  me )

   889                 {

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

   891                 }

   892             }

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

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

   895             {

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

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

   898             edited = ETrue;

   899             }

   900 

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

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

   903             {

   904             edited = ETrue;

   905             }

   906 

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

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

   909             {

   910             edited = ETrue;

   911             }

   912 

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

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

   915             {

   916             edited = ETrue;

   917             }

   918 

   919         }

   920 

   921 

   922 

   923     return edited;

   924     }

   925 

   926 // ---------------------------------------------------------------------------

   927 // CESMRMeetingRequestEntry::GetAlarmL

   928 // ---------------------------------------------------------------------------

   929 //

   930 void CESMRMeetingRequestEntry::GetAlarmL(

   931         MESMRCalEntry::TESMRAlarmType& aAlarmType,

   932         TTime &aAlarmTime )

   933     {

   934     FUNC_LOG;

   935 

   936     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

   937 

   938     aAlarmType = MESMRCalEntry::EESMRAlarmNotFound;

   939     aAlarmTime = Time::NullTTime();

   940 

   941     TFileName alarmInfoResource;

   942     ESMRHelper::LocateResourceFile(

   943             KAlarmInfoResource,

   944             KDC_RESOURCE_FILES_DIR,

   945             alarmInfoResource);

   946 

   947 

   948     CESMRAlarmInfoHandler* alarmInfoHandler =

   949             CESMRAlarmInfoHandler::NewLC();

   950 

   951     alarmInfoHandler->ReadFromResourceL(

   952             alarmInfoResource,

   953             ESRM_ALARM_INFO_TABLE );

   954 

   955     TRAPD( err,

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

   957 

   958     if ( KErrNone == err )

   959         {

   960         aAlarmType = MESMRCalEntry::EESMRAlarmAbsolute;

   961 

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

   963         // relative alarm:

   964         if ( !IsAllDayEventL() )

   965             {

   966             TESMRAlarmInfo alarmInfo;

   967             TRAP( err,

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

   969 

   970             if ( KErrNone == err )

   971                 {

   972                 aAlarmType = MESMRCalEntry::EESMRAlarmRelative;

   973                 if( alarmInfo.iRelativeAlarmInSeconds < KZero )

   974                     {

   975                     aAlarmType = MESMRCalEntry::EESMRAlarmNotFound;

   976                     }

   977                 }

   978             }

   979         }

   980 

   981     CleanupStack::PopAndDestroy( alarmInfoHandler );

   982 

   983     }

   984 

   985 

   986 // ---------------------------------------------------------------------------

   987 // CESMRMeetingRequestEntry::OriginalEntry

   988 // ---------------------------------------------------------------------------

   989 //

   990 const CCalEntry& CESMRMeetingRequestEntry::OriginalEntry()

   991     {

   992     FUNC_LOG;

   993     return *iOrginalEntry;

   994     }

   995 

   996 

   997 // ---------------------------------------------------------------------------

   998 // CESMRMeetingRequestEntry::RoleL

   999 // ---------------------------------------------------------------------------

  1000 //

  1001 TESMRRole CESMRMeetingRequestEntry::RoleL() const

  1002     {

  1003     FUNC_LOG;

  1004 

  1005     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

  1006 

  1007     CESMRCalUserUtil* caluserUtil = CESMRCalUserUtil::NewLC( *iEntry );

  1008     TESMRRole role = caluserUtil->PhoneOwnerRoleL();

  1009     CleanupStack::PopAndDestroy( caluserUtil );

  1010 

  1011 

  1012     return role;

  1013     }

  1014 

  1015 // ---------------------------------------------------------------------------

  1016 // CESMRMeetingRequestEntry::Conflicts

  1017 // ---------------------------------------------------------------------------

  1018 //

  1019 TBool CESMRMeetingRequestEntry::Conflicts() const

  1020     {

  1021     FUNC_LOG;

  1022     return iConflictsExists;

  1023     }

  1024 

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

  1026 // CESMRMeetingRequestEntry::MarkMeetingCancelledL

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

  1028 //

  1029 void CESMRMeetingRequestEntry::MarkMeetingCancelledL()

  1030     {

  1031     FUNC_LOG;

  1032 

  1033     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

  1034 

  1035     TESMRRole role = RoleL();

  1036 

  1037     if ( EESMRRoleOrganizer == role )

  1038         {

  1039         iEntry->SetMethodL( CCalEntry::EMethodCancel );

  1040         iEntry->SetStatusL( CCalEntry::ECancelled );

  1041         }

  1042     else if ( EESMRRoleRequiredAttendee == role ||

  1043               EESMRRoleOptionalAttendee == role ||

  1044               EESMRRoleNonParticipant == role )

  1045         {

  1046         ConstructReplyL( EESMRAttendeeStatusDecline );

  1047         }

  1048 

  1049     }

  1050 

  1051 // ---------------------------------------------------------------------------

  1052 // CESMRMeetingRequestEntry::ConstructReplyL

  1053 //

  1054 // ---------------------------------------------------------------------------

  1055 //

  1056 void CESMRMeetingRequestEntry::ConstructReplyL(

  1057             TESMRAttendeeStatus aStatus )

  1058     {

  1059     FUNC_LOG;

  1060 

  1061     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

  1062 

  1063     CCalAttendee* attendee =

  1064             iMRMailboxUtils.ThisAttendeeL( *iEntry );

  1065 

  1066     if ( !attendee )

  1067         {

  1068 

  1069         User::Leave( KErrNotFound );

  1070         }

  1071 

  1072     CCalAttendee::TCalStatus status(

  1073             CCalAttendee::EDeclined );

  1074 

  1075     CCalEntry::TStatus entryStatus = CCalEntry::ENullStatus;

  1076     switch ( aStatus )

  1077         {

  1078         case EESMRAttendeeStatusAccept:

  1079             status = CCalAttendee::EAccepted;

  1080             entryStatus = CCalEntry::EConfirmed;

  1081             break;

  1082 

  1083         case EESMRAttendeeStatusTentative:

  1084             status = CCalAttendee::ETentative;

  1085             entryStatus = CCalEntry::ETentative;

  1086             break;

  1087         case EESMRAttendeeStatusDecline:

  1088             status = CCalAttendee::EDeclined;

  1089             entryStatus = CCalEntry::ECancelled;

  1090             break;

  1091         default:

  1092             // This should not occur

  1093             __ASSERT_DEBUG(

  1094                     EFalse,

  1095                     Panic( EESMRInvalidReplyType ) );

  1096 

  1097             User::Leave( KErrArgument );

  1098             break;

  1099         }

  1100 

  1101     attendee->SetStatusL(status);

  1102     iEntry->SetStatusL(entryStatus);

  1103     

  1104     iEntry->SetMethodL( CCalEntry::EMethodReply );

  1105 

  1106     }

  1107 

  1108 // ---------------------------------------------------------------------------

  1109 // CESMRMeetingRequestEntry::IsEntryOutOfDateL

  1110 //

  1111 // ---------------------------------------------------------------------------

  1112 //

  1113 TBool CESMRMeetingRequestEntry::IsEntryOutOfDateL() const

  1114     {

  1115     FUNC_LOG;

  1116 

  1117     __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

  1118 

  1119     TBool outOfDate( EFalse );

  1120 

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

  1122     if ( IsOpenedFromMail() && 

  1123          CCalEntry::EMethodCancel != method )

  1124         {

  1125         CCalEntry* dbEntry = NULL;

  1126         

  1127         TRAP_IGNORE( dbEntry = iCalDb.FetchEntryL( iEntry->UidL(),

  1128                                                  iEntry->RecurrenceIdL() ) );

  1129 

  1130         CleanupStack::PushL( dbEntry );

  1131         if ( dbEntry )

  1132             {

  1133             TInt currentSeqNo( iEntry->SequenceNumberL() );

  1134             TInt dbEntrySeqNo( dbEntry->SequenceNumberL() );