--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/meetingui/meetingrequestutils/src/CMRUtilsCalDbMgr.cpp Tue Feb 02 10:12:19 2010 +0200
@@ -0,0 +1,829 @@
+/*
+* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: Implementation for meeting request utils calendar
+* database manager
+*/
+
+
+
+// ----------------------------------------------------------------------------
+// INCLUDE FILES
+// ----------------------------------------------------------------------------
+//
+#include "CMRUtilsCalDbMgr.h"
+#include "CMRUtilsCalDbNormal.h"
+#include "CMRUtilsCalDbTombs.h"
+#include "CMRUtilsCmdIterationAO.h"
+#include "CMRUtilsGraveyardCleaner.h"
+#include "MREntryConsultant.h"
+#include "MRHelpers.h"
+#include "ICalUILog.h"
+#include "CMRUtilsInternal.h"
+#include <ct/RCPointerArray.h>
+#include <CalSession.h>
+#include <CalEntryView.h>
+#include <CalInstance.h>
+#include <CalInstanceView.h>
+#include <CalEntry.h>
+#include <CalCommon.h>
+#include <CalUser.h>
+#include <CalenInterimUtils2.h>
+
+// CONSTANTS
+/// Unnamed namespace for local definitions
+namespace {
+
+const TInt KUidListGranularity = 10;
+
+enum TPanicCode
+ {
+ EPanicIllegalFetchParams = 1,
+ EPanicAccessedWhenUnavailable,
+ EPanicAsyncOpAlreadyExists,
+ EPanicIllegalEntryStatus,
+ EPanicIllegalResurrect,
+ EPanicUnexpectedUidValue
+ };
+
+_LIT( KPanicMsg, "CMRUtilsCalDbMgr" );
+
+void Panic( TPanicCode aReason )
+ {
+ User::Panic( KPanicMsg, aReason );
+ }
+
+} // namespace
+
+// ----------------------------------------------------------------------------
+// MEMBER FUNCTIONS
+// ----------------------------------------------------------------------------
+//
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::NewL
+// ----------------------------------------------------------------------------
+//
+CMRUtilsCalDbMgr* CMRUtilsCalDbMgr::NewL(
+ CCalSession& aCalSession,
+ MMRUtilsObserver& aObserver )
+ {
+ CMRUtilsCalDbMgr* self = new( ELeave ) CMRUtilsCalDbMgr( aCalSession,
+ aObserver );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::CMRUtilsCalDbMgr
+//
+// Constructor.
+// ----------------------------------------------------------------------------
+//
+CMRUtilsCalDbMgr::CMRUtilsCalDbMgr(
+ CCalSession& aCalSession,
+ MMRUtilsObserver& aObserver )
+ : iCurrentAsyncOp( CMRUtils::ENoOperation ),
+ iCalSession( aCalSession ),
+ iObserver( aObserver )
+ {
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::~CMRUtilsCalDbMgr
+//
+// Destructor.
+// ----------------------------------------------------------------------------
+//
+CMRUtilsCalDbMgr::~CMRUtilsCalDbMgr()
+ {
+ delete iGraveyardCleaner;
+ delete iCmdIterator;
+ delete iNormalDb;
+ delete iTombsDb;
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::ConstructL
+// ----------------------------------------------------------------------------
+//
+void CMRUtilsCalDbMgr::ConstructL()
+ {
+ iNormalDb = CMRUtilsCalDbNormal::NewL( iCalSession, *this, *this );
+ iTombsDb = CMRUtilsCalDbTombs::NewL( *this, *this );
+ iCmdIterator = CMRUtilsCmdIterationAO::NewL( *this );
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::HandleCalDbStatus
+// ----------------------------------------------------------------------------
+//
+void CMRUtilsCalDbMgr::HandleCalDbStatus(
+ const CMRUtilsCalDbBase* /*aNotifier*/,
+ MMRUtilsCalDbObserver::TDbStatus aStatus )
+ {
+ // If there is any change in db status, we must stop cleaning:
+ delete iGraveyardCleaner;
+ iGraveyardCleaner = NULL;
+
+ if ( aStatus == EReseting )
+ { // reset db is ongoing, engine becomes unavailable
+ iObserver.HandleCalEngStatus( MMRUtilsObserver::ENotReady );
+ }
+ else if ( iNormalDb->DbStatus() == MMRUtilsCalDbObserver::EFinishedOk &&
+ iTombsDb->DbStatus() == MMRUtilsCalDbObserver::EFinishedOk )
+ {
+ iObserver.HandleCalEngStatus( MMRUtilsObserver::EAvailable );
+ // Both databases are available so we can start idle cleanup
+ // We can ignore the error if it fails, try again next time
+ TRAP_IGNORE(
+ iGraveyardCleaner =
+ CMRUtilsGraveyardCleaner::NewL( *iNormalDb, *iTombsDb );
+ iGraveyardCleaner->StartIdleCleanupL( Time::NullTTime() );
+ )
+ }
+ else if ( iNormalDb->DbStatus() == MMRUtilsCalDbObserver::EFinishedOk &&
+ iTombsDb->DbStatus() == MMRUtilsCalDbObserver::EFinishedError )
+ {
+ iObserver.HandleCalEngStatus(
+ MMRUtilsObserver::EAvailableWithoutTombs );
+ }
+ else if ( iNormalDb->DbStatus() == MMRUtilsCalDbObserver::EFinishedError )
+ {
+ iObserver.HandleCalEngStatus( MMRUtilsObserver::ENotAvailable );
+ }
+
+ // In other cases either db is not yet finished
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::Progress
+// ----------------------------------------------------------------------------
+//
+void CMRUtilsCalDbMgr::Progress( TInt /*aPercentageCompleted*/ )
+ {
+ // Not interested in progress currently
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::NotifyProgress
+// ----------------------------------------------------------------------------
+//
+TBool CMRUtilsCalDbMgr::NotifyProgress()
+ {
+ // Not interested in progress currently
+ return EFalse;
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::Completed
+// ----------------------------------------------------------------------------
+//
+void CMRUtilsCalDbMgr::Completed( TInt aError )
+ {
+ iObserver.HandleOperation( iCurrentAsyncOp, 100, aError );
+ iCurrentAsyncOp = CMRUtils::ENoOperation;
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::NormalDbEntryView
+// ----------------------------------------------------------------------------
+//
+CCalEntryView* CMRUtilsCalDbMgr::NormalDbEntryView()
+ { // NormalDbEntryView will only be called if engine is available
+ return iNormalDb->EntryView();
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::NormalDbInstanceView
+// ----------------------------------------------------------------------------
+//
+CCalInstanceView* CMRUtilsCalDbMgr::NormalDbInstanceView()
+ { // NormalDbInstanceView will only be called if engine is available
+ return iNormalDb->InstanceView();
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::FetchEntriesL
+// ----------------------------------------------------------------------------
+//
+void CMRUtilsCalDbMgr::FetchEntriesL(
+ RPointerArray<CCalEntry>& aCalEntryArray,
+ const CalCommon::TCalTimeRange& aTimeRange )
+ {
+ __ASSERT_DEBUG( aCalEntryArray.Count() == 0,
+ Panic( EPanicIllegalFetchParams ) );
+ aCalEntryArray.ResetAndDestroy();
+ // caller definitely wants to get full copies -> ETrue as 3rd argument:
+ iNormalDb->FetchWithRangeL( aCalEntryArray,
+ aTimeRange,
+ ETrue );
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::FetchEntryL
+// ----------------------------------------------------------------------------
+//
+CCalEntry* CMRUtilsCalDbMgr::FetchEntryL(
+ const TDesC8& aUid,
+ const TCalTime& aRecurrenceId )
+ {
+ __ASSERT_DEBUG( aUid.Length() > 0,
+ Panic( EPanicIllegalFetchParams ) );
+
+ RCPointerArray<CCalEntry> tmpFetchArray;
+ CleanupClosePushL( tmpFetchArray );
+
+ CCalEntry* retVal = NULL;
+
+ TInt index( -1 );
+ if ( EntryExistsInDbL( aUid,
+ aRecurrenceId,
+ *iNormalDb,
+ tmpFetchArray,
+ index ) )
+ {
+ retVal = tmpFetchArray[index];
+ tmpFetchArray.Remove( index ); // ownership transferred to retVal
+ }
+
+ CleanupStack::PopAndDestroy(); // tmpFetchArray
+ return retVal;
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::StoreEntryL
+// ----------------------------------------------------------------------------
+//
+TInt CMRUtilsCalDbMgr::StoreEntryL(
+ CCalEntry& aCalEntry,
+ TBool aToNormalDb )
+ {
+ TInt retVal( KErrNone );
+
+ CMRUtilsCalDbBase* dbToStore = aToNormalDb ? iNormalDb : iTombsDb;
+ CCalenInterimUtils2::StoreL( *( dbToStore->EntryView() ),
+ aCalEntry,
+ ETrue );
+
+ return retVal;
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::UpdateEntryL
+// ----------------------------------------------------------------------------
+//
+TInt CMRUtilsCalDbMgr::UpdateEntryL( const CCalEntry& aCalEntry )
+ {
+ RPointerArray<CCalEntry> calEntryTmpArray( 1 ); // entry not own
+ CleanupClosePushL( calEntryTmpArray );
+ calEntryTmpArray.AppendL( &aCalEntry );
+ TInt numSuccessfulEntry( 0 );
+ // entry view surely exists when status is 'available':
+ iNormalDb->EntryView()->UpdateL( calEntryTmpArray, numSuccessfulEntry );
+ TInt retVal( numSuccessfulEntry == 1 ? KErrNone : KErrGeneral );
+ CleanupStack::PopAndDestroy(); // calEntryTmpArray, only close array
+ return retVal;
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::DeleteEntryL
+// ----------------------------------------------------------------------------
+//
+TInt CMRUtilsCalDbMgr::DeleteEntryL( const TDesC8& aUid )
+ {
+ CDesC8ArrayFlat* uidArray = new( ELeave ) CDesC8ArrayFlat( 1 );
+ CleanupStack::PushL( uidArray );
+ uidArray->AppendL( aUid );
+ // entry view surely exists when status is 'available':
+ iNormalDb->EntryView()->DeleteL( *uidArray );
+ CleanupStack::PopAndDestroy( uidArray );
+ return KErrNone;
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::DeleteEntryL
+// ----------------------------------------------------------------------------
+//
+TInt CMRUtilsCalDbMgr::DeleteEntryL( const TCalLocalUid& aLocalUid )
+ {
+ RArray<TCalLocalUid> localUidArray( 1 );
+ CleanupClosePushL( localUidArray );
+ localUidArray.AppendL( aLocalUid );
+ TInt numSuccessfulEntry( 0 );
+ iNormalDb->EntryView()->DeleteL( localUidArray, numSuccessfulEntry );
+ TInt retVal( numSuccessfulEntry == 1 ? KErrNone : KErrGeneral );
+ CleanupStack::PopAndDestroy(); // localUidArray
+ return retVal;
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::ResetTombsFileL
+// ----------------------------------------------------------------------------
+//
+void CMRUtilsCalDbMgr::ResetTombsFileL()
+ {
+ iTombsDb->ResetDbL();
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::DeleteTombstonesL
+// ----------------------------------------------------------------------------
+//
+void CMRUtilsCalDbMgr::DeleteTombstonesL(
+ const CalCommon::TCalTimeRange& aCalTimeRange )
+ {
+ __ASSERT_DEBUG( iCurrentAsyncOp == CMRUtils::ENoOperation,
+ Panic( EPanicAsyncOpAlreadyExists ) );
+ iTombsDb->EntryView()->DeleteL( aCalTimeRange,
+ CalCommon::EIncludeAppts,
+ *this );
+ iCurrentAsyncOp = CMRUtilsInternal::EDeleteTombstones;
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::StoreEntryCondL
+// aResurrect can only be ETrue if aCheckOnly is EFalse, i.e. when user is
+// really trying to store something.
+// ----------------------------------------------------------------------------
+//
+MMRUtilsTombsExt::TMRUtilsDbResult CMRUtilsCalDbMgr::StoreEntryCondL(
+ CCalEntry& aCalEntry,
+ TBool aResurrect,
+ TBool aCheckOnly )
+ {
+ RCPointerArray<CCalEntry> tmpFetchArray;
+ CleanupClosePushL( tmpFetchArray );
+
+ MMRUtilsTombsExt::TMRUtilsDbResult entryStatus(
+ MMRUtilsTombsExt::EUndefined );
+ TInt index( -1 );
+
+ // 1. Normal db part, if entry is found in there then tombstones aren't
+ // checked at all:
+
+ if ( EntryExistsInDbL( aCalEntry, *iNormalDb, tmpFetchArray, index ) )
+ { // Entry exists in normal db
+ entryStatus = EvaluateExistingEntryL( aCalEntry,
+ *( tmpFetchArray[index] ) );
+ if ( entryStatus == MMRUtilsTombsExt::ECheckedValidUpdate &&
+ !aCheckOnly )
+ {
+ StoreEntryL( aCalEntry );
+ entryStatus = MMRUtilsTombsExt::EStoredUpdate;
+ }
+ else if ( entryStatus == MMRUtilsTombsExt::EErrorCancelled &&
+ aResurrect )
+ {
+ __ASSERT_DEBUG( !aCheckOnly, Panic( EPanicIllegalResurrect ) );
+ StoreEntryL( aCalEntry );
+ entryStatus = MMRUtilsTombsExt::EResurrectedCancelled;
+ }
+ // entry can't be new if it exists in the db already:
+ __ASSERT_DEBUG( entryStatus != MMRUtilsTombsExt::ECheckedValidNew,
+ Panic( EPanicIllegalEntryStatus) );
+ }
+
+ // 2. Tombstone db part (omitted if tombs db unavailable):
+
+ else if ( iTombsDb->DbStatus() == MMRUtilsCalDbObserver::EFinishedOk &&
+ EntryExistsInDbL( aCalEntry, *iTombsDb, tmpFetchArray, index ) )
+ { // Entry has been deleted and is a tombstone now
+ entryStatus = EvaluateExistingEntryL( aCalEntry,
+ *( tmpFetchArray[index] ) );
+
+
+ if ( entryStatus == MMRUtilsTombsExt::ECheckedValidUpdate &&
+ !aCheckOnly )
+ { // Older entry exists in tombstone db, our policy is that
+ // updates are still accepted
+ if ( MREntryConsultant::IsModifyingEntryL( aCalEntry ) &&
+ !OriginatingExistInDbL( aCalEntry ) )
+ { // originating not found in normal db, so modifying entry
+ // is "illegal", cannot be saved
+ entryStatus = MMRUtilsTombsExt::EErrorRecurrence;
+ }
+ else
+ {
+ StoreEntryL( aCalEntry );
+ entryStatus = MMRUtilsTombsExt::EStoredUpdate;
+ // Try to delete this particular tombstone, any further
+ // tombstone cleanup is taken care by a separate class:
+ TRAP_IGNORE( iTombsDb->EntryView()->DeleteL( aCalEntry ) );
+ }
+ }
+ else if ( entryStatus == MMRUtilsTombsExt::EErrorIdenticalExists )
+ { // Identical entry exists in tombstone db
+ if ( aResurrect )
+ {
+ __ASSERT_DEBUG( !aCheckOnly, Panic( EPanicIllegalResurrect ) );
+ if ( MREntryConsultant::IsModifyingEntryL( aCalEntry ) &&
+ !OriginatingExistInDbL( aCalEntry ) )
+ { // originating not found in normal db, so modifying entry
+ // is "illegal", cannot be resurrected
+ entryStatus = MMRUtilsTombsExt::EErrorRecurrence;
+ }
+ else
+ {
+ StoreEntryL( aCalEntry );
+ entryStatus = MMRUtilsTombsExt::EResurrectedDeleted;
+ // Try to delete this particular tombstone, any further
+ // tombstone cleanup is taken care by a separate class:
+ TRAP_IGNORE( iTombsDb->EntryView()->DeleteL( aCalEntry ) );
+ }
+ }
+ else
+ {
+ entryStatus = MMRUtilsTombsExt::EErrorHasBeenDeleted;
+ }
+ }
+ // entry can't be new if it exists in the db already:
+ __ASSERT_DEBUG( entryStatus != MMRUtilsTombsExt::ECheckedValidNew,
+ Panic( EPanicIllegalEntryStatus) );
+ }
+
+ // 3. New entry in this phone:
+
+ else
+ { // Completely new entry (or tombstone has disappeared)
+ entryStatus = EvaluateNewEntryL( aCalEntry );
+ if ( entryStatus == MMRUtilsTombsExt::ECheckedValidNew && !aCheckOnly )
+ {
+ StoreEntryL( aCalEntry );
+ entryStatus = MMRUtilsTombsExt::EStoredNew;
+ }
+
+ // entry can't be update if doesn't exist in the db already:
+ __ASSERT_DEBUG( entryStatus != MMRUtilsTombsExt::ECheckedValidUpdate,
+ Panic( EPanicIllegalEntryStatus) );
+ }
+
+ CleanupStack::PopAndDestroy(); // tmpFetchArray
+ return entryStatus;
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::DeleteEntryCondL
+// ----------------------------------------------------------------------------
+//
+void CMRUtilsCalDbMgr::DeleteEntryCondL( const TDesC8& aUid )
+ {
+ RCPointerArray<CCalEntry> tmpFetchArray;
+ CleanupClosePushL( tmpFetchArray );
+
+ // 1. Delete all found entries from normal db:
+
+ iNormalDb->EntryView()->FetchL( aUid, tmpFetchArray );
+ DeleteEntryL( aUid );
+
+ // 2. Add them to tombstone db, if this fails then no tombstone gets
+ // created, but that isn't a major problem:
+
+ if ( iTombsDb->DbStatus() == MMRUtilsCalDbObserver::EFinishedError )
+ { // if tombstone db isn't available then we omit it silently
+ return;
+ }
+
+ TInt count( tmpFetchArray.Count() );
+ for ( TInt i( 0 ); i < count; ++i )
+ {
+// TODO: currently child entry uid cannot be read anymore after it has been
+// deleted from the db, this might be a bug in CalInterimApi. Check later
+// if it works, if doesn't we could e.g. make a copy of each entry before
+// deleting it and delete and store one at a time, parent as the last one.
+// See also DeleteEntryCondL( const CCalEntry& aCalEntry ) variant below.
+ CCalEntry* tombstone = MRHelpers::CopyEntryLC( *( tmpFetchArray[i] ),
+ tmpFetchArray[i]->MethodL(),
+ MRHelpers::ECopySkeleton );
+ // store to iTombsDb, parent will be added first (it has index 0):
+ // don't care if creating a tombstone would fail
+ TRAP_IGNORE( StoreEntryL( *tombstone, EFalse ) );
+ CleanupStack::PopAndDestroy( tombstone );
+ }
+
+ CleanupStack::PopAndDestroy(); // tmpFetchArray
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::DeleteEntryCondL
+// ----------------------------------------------------------------------------
+//
+void CMRUtilsCalDbMgr::DeleteEntryCondL( const TCalLocalUid& aLocalUid )
+ {
+ CCalEntry* entry = iNormalDb->EntryView()->FetchL( aLocalUid );
+ if ( entry )
+ {
+ CleanupStack::PushL( entry );
+ DeleteEntryCondL( *entry );
+ CleanupStack::PopAndDestroy( entry );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::DeleteEntryCondL
+// ----------------------------------------------------------------------------
+//
+void CMRUtilsCalDbMgr::DeleteEntryCondL( const CCalEntry& aCalEntry )
+ {
+ if ( MREntryConsultant::IsModifyingEntryL( aCalEntry ) )
+ { // Modifying entry
+
+ // 1. Delete entry from normal db:
+
+// TODO: see above the problem of storing children to tombs db
+
+ iNormalDb->EntryView()->DeleteL( aCalEntry );
+
+ // 2. Add it to tombstone db, if this fails then no tombstone gets
+ // created, but that isn't a major problem:
+
+ if ( iTombsDb->DbStatus() == MMRUtilsCalDbObserver::EFinishedError )
+ { // if tombstone db isn't available then we omit it silently
+ return;
+ }
+
+ // We must ensure that originating entry exists in tombstone db,
+ // but if it exists already it mustn't be stored again since that
+ // would automatically clean up any related modifying entries:
+ TInt dummyIndex( -1 ); // unused but required
+ RCPointerArray<CCalEntry> tmpFetchArray;
+ CleanupClosePushL( tmpFetchArray );
+ TBool origExistsInTombsDb = EntryExistsInDbL( aCalEntry.UidL(),
+ TCalTime(),
+ *iTombsDb,
+ tmpFetchArray,
+ dummyIndex );
+ tmpFetchArray.ResetAndDestroy();
+ if ( !origExistsInTombsDb )
+ { // Copy originating entry from normal to tombs db:
+ iNormalDb->EntryView()->FetchL( aCalEntry.UidL(), tmpFetchArray );
+ CCalEntry* orig = MRHelpers::CopyEntryLC( *( tmpFetchArray[0] ),
+ tmpFetchArray[0]->MethodL(),
+ MRHelpers::ECopySkeleton );
+ tmpFetchArray.ResetAndDestroy();
+ // to iTombsDb, don't care if creating a tombstone would fail
+ TRAP_IGNORE( StoreEntryL( *orig, EFalse ) );
+ CleanupStack::PopAndDestroy( orig );
+ }
+ CleanupStack::PopAndDestroy(); // tmpFetchArray
+
+ // Now store the modifying entry to tombstone db:
+ CCalEntry* modif = MRHelpers::CopyEntryLC( aCalEntry,
+ aCalEntry.MethodL(),
+ MRHelpers::ECopySkeleton );
+ // to iTombsDb, don't care if creating a tombstone would fail
+ TRAP_IGNORE( StoreEntryL( *modif, EFalse ) );
+ CleanupStack::PopAndDestroy( modif );
+ }
+
+ else
+ { // Originating entry, this is the same case as deleting with GUID:
+ DeleteEntryCondL( aCalEntry.UidL() );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::DeleteEntryCondL
+// ----------------------------------------------------------------------------
+//
+void CMRUtilsCalDbMgr::DeleteEntryCondL(
+ const CalCommon::TCalTimeRange& aCalTimeRange )
+ {
+ __ASSERT_DEBUG( iCurrentAsyncOp == CMRUtils::ENoOperation,
+ Panic( EPanicAsyncOpAlreadyExists ) );
+
+ RCPointerArray<CCalEntry> tmpFetchArray;
+ CleanupClosePushL( tmpFetchArray );
+ // skeleton copies are enough -> set 3rd argument to EFalse:
+ iNormalDb->FetchWithRangeL( tmpFetchArray, aCalTimeRange, EFalse );
+ iCmdIterator->StartCmdIterationL( tmpFetchArray, CMRUtils::EDeleteEntries );
+ iCurrentAsyncOp = CMRUtils::EDeleteEntries;
+ tmpFetchArray.Reset(); // ownership of entries was transferred
+ CleanupStack::PopAndDestroy(); // tmpFetchArray
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::EntryExistsInDbL
+// ----------------------------------------------------------------------------
+//
+TBool CMRUtilsCalDbMgr::EntryExistsInDbL(
+ const TDesC8& aUid,
+ const TCalTime& aRecurrenceId,
+ const CMRUtilsCalDbBase& aDb,
+ RPointerArray<CCalEntry>& aCalEntryArray,
+ TInt& aIndex ) const
+ {
+ TBool retVal( EFalse );
+ aIndex = -1;
+
+ aDb.EntryView()->FetchL( aUid, aCalEntryArray );
+ TInt count( aCalEntryArray.Count() );
+ for ( TInt i( 0 ); i < count; ++i )
+ {
+ const CCalEntry& dbEntry( *( aCalEntryArray[i] ) );
+ if ( aRecurrenceId.TimeUtcL() == dbEntry.RecurrenceIdL().TimeUtcL() )
+ { // Entry was found in the db,
+ // it may be either originating or modifying entry
+ retVal = ETrue;
+ aIndex = i;
+ }
+ }
+
+ return retVal;
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::EntryExistsInDbL
+// ----------------------------------------------------------------------------
+//
+inline TBool CMRUtilsCalDbMgr::EntryExistsInDbL(
+ const CCalEntry& aEntry,
+ const CMRUtilsCalDbBase& aDb,
+ RPointerArray<CCalEntry>& aCalEntryArray,
+ TInt& aIndex ) const
+ {
+ return EntryExistsInDbL( aEntry.UidL(),
+ aEntry.RecurrenceIdL(),
+ aDb,
+ aCalEntryArray,
+ aIndex );
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::EvaluateExistingEntryL
+// ----------------------------------------------------------------------------
+//
+MMRUtilsTombsExt::TMRUtilsDbResult CMRUtilsCalDbMgr::EvaluateExistingEntryL(
+ const CCalEntry& aEntry,
+ const CCalEntry& aDbEntry ) const
+ {
+ __ASSERT_DEBUG( aEntry.UidL() == aEntry.UidL(),
+ Panic( EPanicUnexpectedUidValue ) );
+ MMRUtilsTombsExt::TMRUtilsDbResult retVal( MMRUtilsTombsExt::EUndefined );
+
+ TInt seq( aEntry.SequenceNumberL() );
+ TInt dbSeq( aDbEntry.SequenceNumberL() );
+ TTime stamp = aEntry.DTStampL().TimeUtcL();
+ TTime dbStamp = aDbEntry.DTStampL().TimeUtcL();
+
+ #ifdef ICALUI_ENABLE_LOGGING
+
+ LOG("CMRUtilsCalDbMgr::EvaluateExistingEntryL");
+ LOG1( "CMRUtilsCalDbMgr::EvaluateExistingEntryL, new entry seq no: %d", seq );
+ TBuf<KLogTimeFormatLength> timeStamp;
+ TDateTime dateTime;
+ dateTime = stamp.DateTime();
+ timeStamp.Format( KLogTimeFormat,
+ dateTime.Hour(),
+ dateTime.Minute(),
+ dateTime.Second(),
+ dateTime.MicroSecond() );
+ LOG1("CMRUtilsCalDbMgr::EvaluateExistingEntryL, new entry DTStamp: %S", &timeStamp );
+ LOG1( "CMRUtilsCalDbMgr::EvaluateExistingEntryL, existing entry seq no: %d", dbSeq );
+ dateTime = dbStamp.DateTime();
+ timeStamp.Format( KLogTimeFormat,
+ dateTime.Hour(),
+ dateTime.Minute(),
+ dateTime.Second(),
+ dateTime.MicroSecond() );
+ LOG1( "CMRUtilsCalDbMgr::EvaluateExistingEntryL, existing entry DTStamp: %S", &timeStamp );
+
+ #endif // ICALUI_ENABLE_LOGGING
+
+ if ( ( seq >= dbSeq ) && ( stamp >= dbStamp ) )
+ {
+ if ( ( seq == dbSeq ) && ( stamp == dbStamp ) )
+ {
+ retVal = MMRUtilsTombsExt::EErrorIdenticalExists;
+ }
+
+ else if ( aDbEntry.StatusL() == CCalEntry::ECancelled )
+ {
+ retVal = MMRUtilsTombsExt::EErrorCancelled;
+ }
+ else
+ {
+ retVal = MMRUtilsTombsExt::ECheckedValidUpdate;
+ }
+ }
+ else
+ {
+ retVal = MMRUtilsTombsExt::EErrorObsolete;
+ }
+
+ return retVal;
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::EvaluateNewEntryL
+// This method is only used with iNormalDb
+// ----------------------------------------------------------------------------
+//
+MMRUtilsTombsExt::TMRUtilsDbResult CMRUtilsCalDbMgr::EvaluateNewEntryL(
+ const CCalEntry& aEntry ) const
+ {
+ MMRUtilsTombsExt::TMRUtilsDbResult retVal( MMRUtilsTombsExt::EUndefined );
+
+ if ( MREntryConsultant::IsModifyingEntryL( aEntry ) &&
+ !IsValidNewModL( aEntry ) )
+ { // recurrence id does not match to any instance of an entry
+ retVal = MMRUtilsTombsExt::EErrorRecurrence;
+ }
+ else
+ {
+ retVal = MMRUtilsTombsExt::ECheckedValidNew;
+ }
+
+ return retVal;
+ }
+
+// ----------------------------------------------------------------------------
+// CMRUtilsCalDbMgr::EvaluateNewEntryL
+// This method is only used with iNormalDb
+// ----------------------------------------------------------------------------
+//
+TBool CMRUtilsCalDbMgr::IsValidNewModL( const CCalEntry& aModEntry ) const
+ {
+ TBool retVal( EFalse );
+ RCPointerArray<CCalInstance> instances; // takes ownership
+ CleanupClosePushL( instances );
+ TCalTime recurrenceId( aModEntry.RecurrenceIdL() );
+ CalCommon::TCalTimeRange range( recurrenceId, recurrenceId );
+
+ iNormalDb->InstanceView()->FindInstanceL( instances,
+ CalCommon::EIncludeAppts,
+ range );
+ TInt count( instances.Count() );
+ for ( TInt i( 0 ); i < count; ++i )
+ {
+
+ #ifdef ICALUI_ENABLE_LOGGING
+
+ LOG("CMRUtilsCalDbMgr::IsValidNewModL");
+ TDateTime dateTime;
+ TBuf<KLogTimeFormatLength> timeStamp;
+
+ dateTime = recurrenceId.TimeUtcL().DateTime();
+ timeStamp.Format( KLogTimeFormat,
+ dateTime.Hour(),
+ dateTime.Minute(),
+ dateTime.Second(),
+ dateTime.MicroSecond() );
+ LOG1( "CMRUtilsCalDbMgr::IsValidNewModL, mod entry uid: %S",
+ &( aModEntry.UidL() ) );
+ LOG1( "CMRUtilsCalDbMgr::IsValidNewModL, mod entry recurrence: %S",
+ &timeStamp );
+
+ dateTime = instances[i]->StartTimeL().TimeUtcL().DateTime();
+ timeStamp.Format( KLogTimeFormat,
+ dateTime.Hour(),
+ dateTime.Minute(),
+ dateTime.Second(),
+ dateTime.MicroSecond() );
+ LOG1( "CMRUtilsCalDbMgr::IsValidNewModL, instance uid: %S",
+ &( instances[i]->Entry().UidL() ) );
+ LOG1( "CMRUtilsCalDbMgr::IsValidNewModL,instance recurrence: %S",
+ &timeStamp );
+
+ #endif // ICALUI_ENABLE_LOGGING
+
+ // When creating a new modifying entry, recurrence id must match
+ // to an existing instance start time (later on start time may get
+ // modified whereas recurrence id remains unchanged).
+ if ( instances[i]->Entry().UidL() == aModEntry.UidL() &&
+ instances[i]->StartTimeL().TimeUtcL() == recurrenceId.TimeUtcL() )
+ {
+ retVal = ETrue;
+ break; // match found, ready to return
+ }
+ }
+ CleanupStack::PopAndDestroy(); // instances, delete array items
+ return retVal;
+ }
+
+
+TBool CMRUtilsCalDbMgr::OriginatingExistInDbL( const CCalEntry& aModEntry )
+ {
+ TInt retVal( EFalse );
+ CCalEntry* dbEntry = FetchEntryL( aModEntry.UidL(), TCalTime() );
+ if ( dbEntry )
+ {
+ delete dbEntry;
+ retVal = ETrue;
+ }
+ return retVal;
+ }
+
+// End of file