/*

* 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 MRUtils implementation

*

*/

//INCLUDE FILES

#include "emailtrace.h"

#include "cesmrutils.h"

#include "cesmrcaldbmgr.h"

// From ESMRSERVICES

#include <esmrpolicies.rsg>

//<cmail>

#include "cesmrpolicymanager.h"

#include "tesmrscenariodata.h"

#include "cesmrpolicy.h"

//</cmail>

#include "cmrentryprocessor.h"

#include "mesmrmeetingrequestentry.h"

#include "cesmrtaskfactory.h"

#include "mesmrtask.h"

#include "cesmrtaskextensionimpl.h"

#include "esmrinternaluid.h"

#include "esmrhelper.h"

#include "esmrentryhelper.h"

// From System

#include <coemain.h>

#include <calentry.h>

#include <calinstance.h>

#include <calsession.h>

#include <calcommon.h>

#include <caluser.h>

#include <cmrmailboxutils.h>

#include <msvapi.h>

#include <msvstd.h>

#include <data_caging_path_literals.hrh>

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

#ifdef _DEBUG

// Definition for MR UTILS panic text

_LIT(KESMRUtilsPanicTxt, "ESMRUtils" );

// MR VIEWER ctrl panic codes

enum TESMRUtilsPanicCode

    {

    EESMRUtilsEntryProcessorNull = 0,   // Entry processon is NULL

    EESMRUtilsInvalidEntry       = 1,   // Invalid calendar entry,

    EESMRUtilsNULLCoeEnv         = 2,   // CCoeEnv is NULL

    EESMRUtilsInvalidType

    };

void Panic(TESMRUtilsPanicCode aPanicCode)

    {

    User::Panic( KESMRUtilsPanicTxt, aPanicCode );

    }

#endif

}  // namespace

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

// ----------------------------------------------------------------------------

// CESMRUtils::CESMRUtils

// ----------------------------------------------------------------------------

//

CESMRUtils::CESMRUtils(

        MMRUtilsObserver& aObserver )

:   iObserver( aObserver )

    {

    FUNC_LOG;

    }

// ----------------------------------------------------------------------------

// CESMRUtils::~CESMRUtils

// ----------------------------------------------------------------------------

//

EXPORT_C CESMRUtils::~CESMRUtils()

    {

    FUNC_LOG;    

    delete iPolicyManager;

    delete iEntryProcessor;

    delete iMRMailboxUtils;

    delete iTaskFactory;

    delete iTaskExtension;

    delete iCalDBMgr;

    }

// ----------------------------------------------------------------------------

// CESMRUtils::NewL

// ----------------------------------------------------------------------------

//

EXPORT_C CESMRUtils* CESMRUtils::NewL(

        MMRUtilsObserver& aObserver )

    {

    FUNC_LOG;

    CESMRUtils* self = new ( ELeave ) CESMRUtils( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// ----------------------------------------------------------------------------

// CESMRUtils::ConstructL

// ----------------------------------------------------------------------------

//

void CESMRUtils::ConstructL()

    {

    FUNC_LOG;

    iPolicyManager = CESMRPolicyManager::NewL();

    }

// ----------------------------------------------------------------------------

// CESMRUtils::CreateExtensionsL

// ----------------------------------------------------------------------------

//

EXPORT_C void CESMRUtils::CreateExtensionsL(

        TESMRCalendarEventType aEntryType )

    {

    FUNC_LOG;

    CESMRTaskFactory* taskFactory = CESMRTaskFactory::NewL(

            aEntryType,

            *iCalDBMgr );

    CleanupStack::PushL( taskFactory );

    CMREntryProcessor* entryProcessor = CMREntryProcessor::NewL(

            aEntryType,

            *iCalDBMgr );

    CleanupStack::PushL( entryProcessor );

    MESMRTaskExtension* taskExtension =

        CESMRTaskExtenstionImpl::NewL( *taskFactory );

    __ASSERT_DEBUG( taskFactory

                    && entryProcessor

                    && taskExtension,

                    Panic( EESMRUtilsInvalidType) );

    delete iTaskFactory;

    iTaskFactory = taskFactory;

    delete iEntryProcessor;

    iEntryProcessor = entryProcessor;

    delete iTaskExtension;

    iTaskExtension = taskExtension;

    CleanupStack::Pop( 2, taskFactory );

    }

// ----------------------------------------------------------------------------

// CESMRUtils::DeleteWithUiL

// ----------------------------------------------------------------------------

//

EXPORT_C TInt CESMRUtils::DeleteWithUiL(

    const CCalEntry& aEntry,

    TMsvId /*aMailbox*/ )

    {

    FUNC_LOG;

    RPointerArray<CCalEntry> entries;

    CleanupClosePushL( entries );

    User::LeaveIfError( entries.Append( &aEntry ) );

    CreateExtensionsL( ESMREntryHelper::EventTypeL( aEntry ) );

    iEntryProcessor->ProcessL( &entries );

    MESMRMeetingRequestEntry& mrEntry = 

            static_cast< MESMRMeetingRequestEntry& >(

                    iEntryProcessor->ESMREntryL() );

    if ( mrEntry.IsRecurrentEventL() )

        {

        mrEntry.SetModifyingRuleL(

                MESMRMeetingRequestEntry::EESMRAllInSeries );

        }

    mrEntry.MarkMeetingCancelledL();

    iTaskExtension->DeleteAndSendMRL(

            EESMRCmdDeleteMR,

            mrEntry );

    CleanupStack::PopAndDestroy( &entries );

    return KErrNone;

    }

// ----------------------------------------------------------------------------

// CESMRUtils::DeleteWithUiL

// ----------------------------------------------------------------------------

//

EXPORT_C TInt CESMRUtils::DeleteWithUiL(

    CCalInstance* aInstance,

    TMsvId /*aMailbox*/ )

    {

    FUNC_LOG;

    CreateExtensionsL( ESMREntryHelper::EventTypeL( aInstance->Entry() ) );

    iEntryProcessor->ProcessL( *aInstance );

    MESMRMeetingRequestEntry& mrEntry = 

            static_cast< MESMRMeetingRequestEntry& >(

                    iEntryProcessor->ESMREntryL() );

    mrEntry.SetModifyingRuleL(

            MESMRMeetingRequestEntry::EESMRThisOnly );

    mrEntry.MarkMeetingCancelledL();

    iTaskExtension->DeleteAndSendMRL(

                EESMRCmdDeleteMR,

                mrEntry );

    // aInstance is not added to CleanupStack, because calendar

    // already has it.

    delete aInstance;

    return KErrNone;

    }

// ----------------------------------------------------------------------------

// CESMRUtils::SendWithUiL

// ----------------------------------------------------------------------------

//

EXPORT_C void CESMRUtils::SendWithUiL(

    const CCalEntry& aEntry ,

    TMsvId /*aMailbox*/ )

    {

    FUNC_LOG;

    RPointerArray<CCalEntry> entries;

    CleanupClosePushL( entries );

    User::LeaveIfError( entries.Append( &aEntry ) );

    CreateExtensionsL( ESMREntryHelper::EventTypeL( aEntry ) );

    iEntryProcessor->ProcessL( &entries );

    //MESMRMeetingRequestEntry&  = processor->ESMREntryL();

    MESMRMeetingRequestEntry& mrEntry = 

            static_cast< MESMRMeetingRequestEntry& >(

                    iEntryProcessor->ESMREntryL() );

    if ( mrEntry.IsRecurrentEventL() )

            {

            mrEntry.SetModifyingRuleL(

                    MESMRMeetingRequestEntry::EESMRAllInSeries );

            }

    iTaskExtension->ForwardMRAsEmailL(

    			EESMRCmdForwardAsMail,

                mrEntry );

    CleanupStack::PopAndDestroy( &entries );

    }

// ----------------------------------------------------------------------------

// CESMRUtils::ExtensionL

// ----------------------------------------------------------------------------

//

EXPORT_C TAny* CESMRUtils::ExtensionL( TUid aExtensionUid )

    {

    FUNC_LOG;

    TAny* extension = NULL;

    switch ( aExtensionUid.iUid )

        {

        case KESMRPolicyMgrUid:

            extension = static_cast<TAny*>(iPolicyManager);

            break;

        case KESMRMREntryProcessorUid:

            extension = static_cast<TAny*>(iEntryProcessor);

            break;

        case KESMRTaskExtensionUid:

            extension = static_cast<TAny*>(iTaskExtension);

            break;

        default:

            extension = NULL;

            break;

        }

    return extension;

    }

// ----------------------------------------------------------------------------

// CESMRUtils::SessionSetupL

// This template method is called as a part of the ECom plugin construction.

// This replaces much of the ordinary ConstructL() functionality, a template

// method is easier for transmitting parameters.

// ----------------------------------------------------------------------------

//

EXPORT_C void CESMRUtils::SessionSetupL(

    CCalSession& aCalSession,

    CMsvSession* aMsvSession )

    {

    FUNC_LOG;

    // Asynchronous initialization of CESMRServicesCalDbMgr:

    iCalDBMgr = CESMRCalDbMgr::NewL( aCalSession,

                                     *this );

    iMRMailboxUtils = CMRMailboxUtils::NewL( aMsvSession );

    }

// ----------------------------------------------------------------------------

// CESMRUtils::HandleCalEngStatus

// ----------------------------------------------------------------------------

//

void CESMRUtils::HandleCalEngStatus( TMRUtilsCalEngStatus aStatus )

    {

    FUNC_LOG;

    iCalEngStatus = aStatus;

    iObserver.HandleCalEngStatus( iCalEngStatus );

    }

// ----------------------------------------------------------------------------

// CESMRUtils::HandleOperation

// ----------------------------------------------------------------------------

//

void CESMRUtils::HandleOperation(

        TInt /*aType*/,

        TInt /*aPercentageCompleted*/,

        TInt /*aStatus*/ )

    {

    FUNC_LOG;

    // Do nothing

    }

// End of file