--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/meetingrequest/mrentry/src/cesmrentryprocessor.cpp Thu Dec 17 08:39:21 2009 +0200
@@ -0,0 +1,955 @@
+/*
+* Copyright (c) 2007-2009 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 : ESMR entry processor implementation
+* Version : %version: tr1sido#12 %
+*
+*/
+
+
+// INCLUDE FILES
+#include "emailtrace.h"
+#include "cesmrentryprocessor.h"
+#include "cesmrcaldbmgr.h"
+#include "cesmrmeetingrequestentry.h"
+#include "cesmrconflictchecker.h"
+#include "esmrhelper.h"
+#include "esmrinternaluid.h"
+#include "cesmrfsmailboxutils.h"
+
+//<cmail>
+#include "esmrdef.h"
+//</cmail>
+#include <e32std.h>
+#include <calentry.h>
+#include <calinstance.h>
+#include <calrrule.h>
+#include <caluser.h>
+#include <caltime.h>
+#include <CalenInterimUtils2.h>
+#include <cmrmailboxutils.h>
+#include <MAgnEntryUi.h>
+//<cmail>
+#include "FreestyleEmailUiConstants.h"
+#include "cesmrrecurrenceinfohandler.h"
+//</cmail>
+#include "esmrentryhelper.h"
+#include "tesmrinputparams.h"
+
+/// Unnamed namespace for local definitions
+namespace {
+
+// Definition for first item index
+const TInt KFirstEntryIndex = 0;
+
+// Definition for zero interval
+const TInt KZeroInterval = 0;
+
+#ifdef _DEBUG
+
+// Definition for module panic text
+_LIT( KESMRProcessorPanicTxt, "ESMREntryProcessor" );
+
+/**
+ * ESMREntryProcessor panic codes
+ */
+enum TESMREntryProcessorPanic
+ {
+ // Input entry array is empty
+ EESMRProcessorEmptyEntryArray = 1,
+ // Too many input entries
+ EESMRProcessorTooManyEntries = 2,
+ // entries are not processed
+ EESMRProcessorEntriesNotProcessed,
+ // View mode for policy resolving
+ // cannot be check.
+ EESMRProcessorCannotCheckViewMode,
+ };
+
+/**
+ * Raises panic.
+ * @param aPanic Panic code
+ */
+void Panic(TESMREntryProcessorPanic aPanic)
+ {
+
+ User::Panic( KESMRProcessorPanicTxt(),
+ aPanic);
+ }
+
+/**
+ * Logs scenatio data
+ * @param aData Reference to scenario data.
+ */
+void LogScenatioData(
+ const TESMRScenarioData& /*aScenarioData*/ )
+ {
+
+
+
+
+ }
+
+#endif // _DEBUG
+
+/**
+ * Cleanup operation for RPointerArray.
+ *
+ * @param aArray Pointer to RPointerArray.
+ */
+void CalEntryPointerArrayCleanup( TAny* aArray )
+ {
+ RPointerArray<CCalEntry>* entryArray =
+ static_cast<RPointerArray<CCalEntry>*>( aArray );
+
+ entryArray->ResetAndDestroy();
+ entryArray->Close();
+ }
+
+/**
+ * Sets child entry's start and end time.
+ *
+ * @param aChild Reference to child entry
+ * @param aParent Reference to parent entry
+ * @param aChildEnd Child entry's start time
+ */
+void SetInstanceStartAndEndL(
+ CCalEntry& aChild,
+ const CCalEntry& aParent,
+ const TCalTime& aChildStart )
+ {
+ TTime parentStart( aParent.StartTimeL().TimeUtcL() );
+ TTime parentEnd( aParent.EndTimeL().TimeUtcL() );
+ TTime childStart( aChildStart.TimeUtcL() );
+ const TTime KNullTime( Time::NullTTime() );
+
+ if ( KNullTime == parentStart ||
+ KNullTime == parentEnd ||
+ KNullTime == childStart )
+ {
+ // Invalid time --> Leaving
+ User::Leave( KErrArgument );
+ }
+
+ TTimeIntervalMicroSeconds duration( KZeroInterval );
+ duration = parentEnd.MicroSecondsFrom( parentStart );
+ TCalTime childEnd;
+ childEnd.SetTimeUtcL( childStart + duration );
+
+ aChild.SetStartAndEndTimeL( aChildStart, childEnd );
+ }
+
+void CheckRepeatUntilValidityL(
+ CCalEntry& aEntry,
+ const TCalTime& aInstanceTime )
+ {
+
+ if ( ESMREntryHelper::IsRepeatingMeetingL(aEntry) &&
+ !ESMREntryHelper::IsModifyingEntryL(aEntry) )
+ {
+ TCalRRule originalRRule;
+ if ( aEntry.GetRRuleL( originalRRule ) )
+ {
+ TCalTime endTime = aEntry.EndTimeL();
+ TCalTime startTime = aEntry.StartTimeL();
+
+ TTimeIntervalMicroSeconds duration =
+ endTime.TimeLocalL().MicroSecondsFrom(
+ startTime.TimeLocalL() );
+
+ TTime instanceEndTime( aInstanceTime.TimeLocalL() );
+ instanceEndTime += duration;
+ TCalTime repeatUntilTime = originalRRule.Until();
+
+ TDateTime repeat = repeatUntilTime.TimeLocalL().DateTime();
+ TDateTime instanceEndDatetime = instanceEndTime.DateTime();
+
+ if ( repeatUntilTime.TimeLocalL() < instanceEndTime )
+ {
+ // reset the recurrence so, that the repeat until
+ // time is included in repeat range. This is done,
+ // because when setting the instance start and end
+ // time, the CCalEntry implementation clears the
+ // recurrence information if the end time is
+ // after repeat until end time.
+ // CCalEntry forces the repeat until time to be
+ // same than last entry's start time when storing the
+ // entry to db. Reason uknown.
+ TCalRRule rRule;
+ rRule.SetDtStart( originalRRule.DtStart() );
+ rRule.SetType( originalRRule.Type() );
+
+ TCalTime newUntil;
+ newUntil.SetTimeLocalL( instanceEndTime );
+ rRule.SetUntil( newUntil );
+ rRule.SetInterval( originalRRule.Interval() );
+ aEntry.SetRRuleL( rRule );
+ }
+ }
+ }
+ }
+
+} // namespace
+
+// ======== MEMBER FUNCTIONS ========
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::CESMREntryProcessor
+// ---------------------------------------------------------------------------
+//
+inline CESMREntryProcessor::CESMREntryProcessor(
+ CMRMailboxUtils& aMRMailboxUtils,
+ MESMRCalDbMgr& aDbMgr )
+: iMRMailboxUtils( aMRMailboxUtils ),
+ iDbMgr( aDbMgr )
+ {
+ FUNC_LOG;
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::~CESMREntryProcessor
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CESMREntryProcessor::~CESMREntryProcessor()
+ {
+ FUNC_LOG;
+ delete iESMREntry;
+ delete iMbUtils;
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::ConstructL
+// ---------------------------------------------------------------------------
+//
+void CESMREntryProcessor::ConstructL()
+ {
+ FUNC_LOG;
+ iMbUtils =
+ CESMRFsMailboxUtils::NewL( iMRMailboxUtils );
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::NewL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CESMREntryProcessor* CESMREntryProcessor::NewL(
+ CMRMailboxUtils& aMRMailboxUtils,
+ MESMRCalDbMgr& aDbMgr )
+ {
+ FUNC_LOG;
+
+ CESMREntryProcessor* self =
+ new (ELeave) CESMREntryProcessor(
+ aMRMailboxUtils, aDbMgr );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+
+
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::ExtensionUid
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TUid CESMREntryProcessor::ExtensionUid()
+ {
+ FUNC_LOG;
+ return TUid::Uid( KESMRMREntryProcessorUid );
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::ProcessL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CESMREntryProcessor::ProcessL(
+ const MAgnEntryUi::TAgnEntryUiInParams* aParams,
+ RPointerArray<CCalEntry>* aEntries )
+ {
+ FUNC_LOG;
+
+ iParams = aParams;
+ ProcessL( aEntries );
+ CheckViewModeL();
+
+ if ( !IsDataOk() )
+ {
+ // Data is not ok --> Leave
+ User::Leave( KErrArgument );
+ }
+
+ // Check mail parameters
+ if ( iParams && iParams->iSpare )
+ {
+ CCalEntry* entry = &iESMREntry->Entry();
+ if(entry)
+ {
+ TBool recurrent(EFalse);
+ recurrent = iESMREntry->IsRecurrentEventL();
+
+ if(recurrent)
+ {
+ if ( !ESMREntryHelper::IsModifyingEntryL(*entry) )
+ {
+ iESMREntry->SetModifyingRuleL( MESMRMeetingRequestEntry::EESMRAllInSeries );
+
+ SetPhoneOwnerToOwnEntryL();
+ }
+ }
+ }
+ }
+
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::ProcessL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CESMREntryProcessor::ProcessL(
+ RPointerArray<CCalEntry>* aEntries )
+ {
+ FUNC_LOG;
+
+ __ASSERT_DEBUG( aEntries->Count() > 0,
+ Panic( EESMRProcessorEmptyEntryArray ) );
+
+ iMREntries = aEntries;
+
+ // Set initial values to scenario data
+ iScenData.iRole = EESMRRoleUndef;
+ iScenData.iViewMode = EESMRViewUndef;
+ iScenData.iCallingApp = EESMRAppUndef;
+
+ SetPhoneOwnerL();
+ CreateESMREntryL();
+ CheckOrganizerL();
+
+ iESMREntry->SetModifyingRuleL(
+ MESMRMeetingRequestEntry::EESMRThisOnly );
+
+ if ( iParams && MAgnEntryUi::ECreateNewEntry == iParams->iEditorMode )
+ {
+ iESMREntry->SetDefaultValuesToEntryL();
+ }
+
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::ProcessL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CESMREntryProcessor::ProcessL(
+ CCalInstance& aInstance )
+ {
+ FUNC_LOG;
+
+ RPointerArray<CCalEntry> entries;
+ CleanupStack::PushL(
+ TCleanupItem(
+ CalEntryPointerArrayCleanup,
+ &entries ) );
+
+ // Fetches parent entry. We need to construct entry with
+ // correct time.
+ CCalEntry &entry = aInstance.Entry();
+ CCalEntry* instanceEntry = ESMRHelper::CopyEntryL(
+ entry,
+ entry.MethodL(),
+ ESMRHelper::ECopyFull );
+
+ entries.Append(instanceEntry);
+
+ // Setting start and end time for child entry
+ CheckRepeatUntilValidityL(
+ *instanceEntry,
+ aInstance.StartTimeL() );
+
+ SetInstanceStartAndEndL(
+ *instanceEntry,
+ entry,
+ aInstance.StartTimeL() );
+
+ // Filling child with correct data
+ // This can be replaced withCCalenInterimUtils2::PopulateChildFromParentL
+ // after its memory leak has been fixed.
+ ESMRHelper::PopulateChildFromParentL(
+ *instanceEntry,
+ entry );
+
+ ProcessL( &entries );
+
+ if ( !iESMREntry )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ // Mark only this entry to be affected.
+ iESMREntry->SetModifyingRuleL(
+ MESMRMeetingRequestEntry::EESMRThisOnly );
+
+ CleanupStack::PopAndDestroy( &entries );
+
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::SwitchToForwardL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CESMREntryProcessor::SwitchToForwardL()
+ {
+ FUNC_LOG;
+
+ if ( !iESMREntry )
+ {
+ // No entries has been processed yet.
+ User::Leave( KErrNotReady );
+ }
+
+ iESMREntry->SwitchToForwardL();
+
+ // Rest of the scenario data remains as it is
+ iScenData.iViewMode = EESMRForwardMR;
+
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::SwitchToViewL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CESMREntryProcessor::SwitchToEditL()
+ {
+ FUNC_LOG;
+
+ if ( !iESMREntry )
+ {
+ // No entries has been processed yet.
+ User::Leave( KErrNotReady );
+ }
+
+ iESMREntry->SwitchToOrginalL();
+
+ // Rest of the scenario data remains as it is
+ iScenData.iViewMode = EESMREditMR;
+
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::SwitchToViewL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CESMREntryProcessor::SwitchToViewL()
+ {
+ FUNC_LOG;
+
+ if ( !iESMREntry )
+ {
+ // No entries has been processed yet.
+ User::Leave( KErrNotReady );
+ }
+
+ iESMREntry->SwitchToOrginalL();
+
+ // Rest of the scenario data remains as it is
+ iScenData.iViewMode = EESMRViewMR;
+
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::SwitchToTrackL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CESMREntryProcessor::SwitchToTrackL()
+ {
+ FUNC_LOG;
+
+ if ( !iESMREntry )
+ {
+ // No entries has been processed yet.
+ User::Leave( KErrNotReady );
+ }
+
+ iESMREntry->SwitchToOrginalL();
+
+ // Rest of the scenario data remains as it is
+ iScenData.iViewMode = EESMRTrackingViewMR;
+ iScenData.iRole = EESMRRoleOrganizer;
+ iScenData.iEntryType = EESMREventTypeAppt;
+
+
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::ESMREntryL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C MESMRMeetingRequestEntry& CESMREntryProcessor::ESMREntryL()
+ {
+ FUNC_LOG;
+ CreateESMREntryL();
+ return *iESMREntry;
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::ResetL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CESMREntryProcessor::ResetL()
+ {
+ FUNC_LOG;
+
+ iScenData.iRole = EESMRRoleUndef;
+ iScenData.iViewMode = EESMRViewUndef;
+ iScenData.iCallingApp = EESMRAppUndef;
+
+ delete iESMREntry;
+ iESMREntry = NULL;
+
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::ProcessOutputParametersL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CESMREntryProcessor::ProcessOutputParametersL(
+ MAgnEntryUi::TAgnEntryUiOutParams& aOutParams,
+ TESMRCommand aCommand )
+ {
+ FUNC_LOG;
+
+ __ASSERT_DEBUG( iESMREntry, Panic(EESMRProcessorEntriesNotProcessed) );
+
+ if ( !iParams ||
+ EESMRForwardMR == iScenData.iViewMode ||
+ EESMRViewUndef == iScenData.iViewMode )
+ {
+ // No input parameters supplied --> Output parameters cannot be set
+ return;
+ }
+
+ TBool handlingInstanceOnly(
+ iESMREntry->IsRecurrentEventL() &&
+ MESMRCalEntry::EESMRThisOnly == iESMREntry->RecurrenceModRule() );
+
+ switch ( aCommand )
+ {
+ case EESMRCmdSendMR:
+ case EESMRCmdSendMRUpdate:
+ case EESMRCmdSaveMR:
+ case EESMRCmdAcceptMR:
+ case EESMRCmdTentativeMR:
+ {
+ aOutParams.iAction = MAgnEntryUi::EMeetingSaved;
+ if ( handlingInstanceOnly )
+ {
+ aOutParams.iAction = MAgnEntryUi::EInstanceRescheduled;
+ }
+ }
+ break;
+
+ case EESMRCmdDeclineMR:
+ case EESMRCmdDeleteMR:
+ {
+ aOutParams.iAction = MAgnEntryUi::EMeetingDeleted;
+ if ( handlingInstanceOnly )
+ {
+ aOutParams.iAction = MAgnEntryUi::EInstanceDeleted;
+ }
+ }
+ break;
+
+ default:
+ {
+ aOutParams.iAction = MAgnEntryUi::ENoAction;
+ }
+ break;
+ }
+
+ if ( handlingInstanceOnly )
+ {
+ aOutParams.iNewInstanceDate =
+ iESMREntry->Entry().StartTimeL();
+ }
+ else if ( MAgnEntryUi::ENoAction != aOutParams.iAction )
+ {
+ // Copy entry details to input entry
+ CCalEntry& baseEntry = *((*iMREntries)[KFirstEntryIndex]);
+ baseEntry.CopyFromL( iESMREntry->Entry() );
+
+ TCalTime instanceTime = iESMREntry->Entry().StartTimeL();
+
+ if ( MESMRCalEntry::EESMRAllInSeries == iESMREntry->RecurrenceModRule() )
+ {
+ // For recurrent event there might be exceptions
+ // and therefore the first possible start time
+ // is set to putput params
+ TCalTime end;
+ CESMRRecurrenceInfoHandler* recurrenceHandler =
+ CESMRRecurrenceInfoHandler::NewLC( iESMREntry->Entry() );
+
+ recurrenceHandler->GetFirstInstanceTimeL(
+ instanceTime,
+ end );
+
+ CleanupStack::PopAndDestroy( recurrenceHandler );
+ recurrenceHandler = NULL;
+ aOutParams.iNewInstanceDate = instanceTime;
+ }
+ else
+ {
+ aOutParams.iNewInstanceDate.SetTimeLocalL(
+ iESMREntry->Entry().StartTimeL().TimeLocalL() );
+ }
+ }
+ else
+ {
+ aOutParams.iNewInstanceDate.SetTimeLocalL( Time::NullTTime() );
+ }
+
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::SetPhoneOwnerL
+// ---------------------------------------------------------------------------
+//
+void CESMREntryProcessor::SetPhoneOwnerL()
+ {
+ FUNC_LOG;
+
+ TInt count( iMREntries->Count() );
+ for ( TInt i( 0 ); i < count; ++i )
+ {
+ // Set phone owner for all entries
+ CCalEntry& entry = *( (*iMREntries)[i] );
+
+ TESMRInputParams* inputParams = NULL;
+ if ( iParams )
+ {
+ inputParams = (TESMRInputParams*)(iParams->iSpare);
+ }
+
+ TInt err(KErrNone);
+ if ( inputParams &&
+ inputParams->iMailClient &&
+ inputParams->iMailMessage )
+ {
+ err = iMbUtils->SetPhoneOwnerL(
+ entry,
+ *(inputParams->iMailClient),
+ *(inputParams->iMailMessage) );
+ }
+ else if ( iParams )
+ {
+ err = iMbUtils->SetPhoneOwnerL(
+ entry,
+ iParams->iMailBoxId );
+ }
+ else
+ {
+ err = iMbUtils->SetPhoneOwnerL( entry );
+ }
+
+ if ( KErrNone != err )
+ {
+ User::Leave( KErrArgument );
+ }
+ }
+
+ // set iOwnerRole, use entry at index zero:
+ CCalEntry& baseEntry = *( (*iMREntries)[KFirstEntryIndex] );
+ if ( iMRMailboxUtils.IsOrganizerL( baseEntry ) )
+ {
+ iScenData.iRole = EESMRRoleOrganizer;
+ }
+ else
+ {
+ // We are not organizer. Let's see if we are in attendee list
+ // or not.
+ CCalAttendee* thisAttendee =
+ iMRMailboxUtils.ThisAttendeeL( baseEntry );
+ if ( thisAttendee )
+ {
+ switch ( thisAttendee->RoleL() )
+ {
+ case CCalAttendee::EOptParticipant:
+ {
+ iScenData.iRole = EESMRRoleOptionalAttendee;
+ break;
+ }
+ case CCalAttendee::ENonParticipant:
+ {
+ iScenData.iRole = EESMRRoleNonParticipant;
+ break;
+ }
+ case CCalAttendee::EReqParticipant: // fall through
+ case CCalAttendee::EChair: // fall through
+ default:
+ { // Note: chair MUST NOT be interpreted as organizer
+ // Req.participant is not correct either but has less
+ // side effects.
+ iScenData.iRole = EESMRRoleRequiredAttendee;
+ break;
+ }
+ }
+ }
+ else
+ {
+ // Phone owner cannot be set --> Leave
+ User::Leave( KErrCorrupt );
+ }
+ }
+
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::CheckViewModeL
+// ---------------------------------------------------------------------------
+//
+void CESMREntryProcessor::CheckViewModeL()
+ {
+ FUNC_LOG;
+
+ // View mode cannot be checked
+ __ASSERT_DEBUG(
+ iESMREntry,
+ Panic(EESMRProcessorCannotCheckViewMode) );
+
+ TInt32 callingAppUid = iParams->iCallingApp.iUid;
+ switch ( callingAppUid )
+ {
+ case KUidCalendarApplication:
+ {
+ iScenData.iCallingApp = EESMRAppCalendar;
+ iScenData.iViewMode = EESMRViewMR;
+ if ( MAgnEntryUi::EViewEntry == iParams->iEditorMode )
+ {
+ if ( iESMREntry->IsAllDayEventL() )
+ {
+ iScenData.iViewMode = EESMRViewAllDayMR;
+ }
+ }
+ else
+ {
+ iScenData.iViewMode = EESMREditMR;
+ }
+ break;
+ }
+ case KUidMceMailApplication:
+ case KUidEsMailApplication:
+ case KUidBVAApplication:
+ {
+ iScenData.iCallingApp = EESMRAppESEmail;
+ iScenData.iViewMode = EESMRViewMR;
+
+ if ( iESMREntry->IsAllDayEventL() )
+ {
+ iScenData.iViewMode = EESMRViewAllDayMR;
+ }
+ break;
+ }
+ default:
+ {
+ //error situation, should never come here
+ // Setting data to undef --> will leave later on.
+ iScenData.iViewMode = EESMRViewUndef;
+ break;
+ }
+ }
+
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::SetPhoneOwnerL
+// ---------------------------------------------------------------------------
+//
+TBool CESMREntryProcessor::IsDataOk() const
+ {
+ FUNC_LOG;
+
+#ifdef _DEBUG
+ LogScenatioData( iScenData );
+#endif
+
+ TBool retVal(ETrue);
+
+ // Check that all values has been set and there is no
+ // undefined values. Policies cannot be resolved, if
+ // scenario data is undefined.
+ if ( EESMRRoleUndef == iScenData.iRole ||
+ EESMRViewUndef == iScenData.iViewMode ||
+ EESMRAppUndef == iScenData.iCallingApp )
+ {
+ retVal = EFalse;
+ }
+
+
+
+ return retVal;
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::CreateESMREntryL
+// ---------------------------------------------------------------------------
+//
+void CESMREntryProcessor::CreateESMREntryL()
+ {
+ FUNC_LOG;
+
+ __ASSERT_DEBUG( iMREntries, Panic(EESMRProcessorEntriesNotProcessed) );
+
+ if ( !iESMREntry )
+ {
+ // ES MR Entry is created
+ CCalEntry& base = *((*iMREntries)[KFirstEntryIndex]);
+ HBufC* description = NULL;
+ TRAPD( err, description = base.DescriptionL().AllocL() );
+ CleanupStack::PushL( description );
+ if ( KErrNone != err )
+ {
+ User::Leave( KErrCorrupt );
+ }
+ CleanupStack::PopAndDestroy( description );
+ description = NULL;
+
+ CCalEntry* entry =
+ ESMRHelper::CopyEntryLC(
+ base,
+ base.MethodL(),
+ ESMRHelper::ECopyFull );
+
+ CESMRConflictChecker* conflictChecker =
+ CESMRConflictChecker::NewL(iDbMgr);
+ CleanupStack::PushL( conflictChecker );
+
+ RPointerArray<CCalEntry> conflicts;
+ CleanupStack::PushL(
+ TCleanupItem(
+ CalEntryPointerArrayCleanup,
+ &conflicts ) );
+
+ conflictChecker->FindConflictsL( *entry, conflicts );
+ TBool conflictsExists( conflicts.Count() );
+
+ if ( iParams &&
+ KUidCalendarApplication == iParams->iCallingApp.iUid )
+ {
+ // Setting start and end time for child entry
+ CheckRepeatUntilValidityL(
+ *entry,
+ iParams->iInstanceDate );
+
+ SetInstanceStartAndEndL(
+ *entry,
+ base,
+ iParams->iInstanceDate );
+ }
+
+ TESMRInputParams* inputParams = NULL;
+ if ( iParams )
+ {
+ inputParams = (TESMRInputParams*)(iParams->iSpare);
+ }
+
+ iESMREntry =
+ CESMRMeetingRequestEntry::NewL(
+ *entry,
+ iMRMailboxUtils,
+ iDbMgr,
+ conflictsExists,
+ inputParams );
+
+ CleanupStack::PopAndDestroy(); // conflicts
+ CleanupStack::PopAndDestroy( conflictChecker );
+ CleanupStack::PopAndDestroy( entry );
+
+ SetPhoneOwnerToOwnEntryL();
+ }
+
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::CheckOrganizerL
+// ---------------------------------------------------------------------------
+//
+void CESMREntryProcessor::CheckOrganizerL()
+ {
+ FUNC_LOG;
+
+ __ASSERT_DEBUG( iMREntries, Panic(EESMRProcessorEntriesNotProcessed) );
+
+ if ( EESMRRoleOrganizer == iScenData.iRole )
+ {
+ CCalEntry& entry = *((*iMREntries)[KFirstEntryIndex]);
+
+ CCalUser *phoneOwner = entry.PhoneOwnerL();
+
+ if ( !phoneOwner )
+ {
+ User::Leave( KErrCorrupt );
+ }
+
+ CCalUser* organizer = ESMRHelper::CopyUserLC( *phoneOwner );
+
+ // Ownership is transferred
+ entry.SetOrganizerL( organizer );
+ CleanupStack::Pop( organizer );
+ }
+
+ }
+
+// ---------------------------------------------------------------------------
+// CESMREntryProcessor::SetPhoneOwnerToOwnEntryL
+// ---------------------------------------------------------------------------
+//
+void CESMREntryProcessor::SetPhoneOwnerToOwnEntryL()
+ {
+ FUNC_LOG;
+
+ // Phone owner cannot be checked
+ __ASSERT_DEBUG(
+ iESMREntry,
+ Panic(EESMRProcessorEntriesNotProcessed) );
+
+ TESMRInputParams* inputParams = NULL;
+ if ( iParams )
+ {
+ inputParams = (TESMRInputParams*)(iParams->iSpare);
+ }
+
+ TInt err(KErrNone);
+ if ( inputParams &&
+ inputParams->iMailClient &&
+ inputParams->iMailMessage )
+ {
+ err = iMbUtils->SetPhoneOwnerL(
+ iESMREntry->Entry(),
+ *(inputParams->iMailClient),
+ *(inputParams->iMailMessage) );
+ }
+ else if ( iParams )
+ {
+ err = iMbUtils->SetPhoneOwnerL(
+ iESMREntry->Entry(),
+ iParams->iMailBoxId );
+ }
+ else
+ {
+ err = iMbUtils->SetPhoneOwnerL( iESMREntry->Entry() );
+ }
+
+ User::LeaveIfError( err );
+
+ }
+
+// EOF
+