/*

* 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   

*

*/

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

// INCLUDE FILES

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

//

#include "CMRUtilsImpl.h"

#include "MRUtilsFactory.h"

#include "CMRUtilsEmailSender.h"

#include "CMRUtilsCalDbMgr.h"

#include "MRHelpers.h"

#include "ICalUILog.h"

#include <CalEntry.h>

#include <CalSession.h>

#include <CalCommon.h>

#include <CalUser.h>

#include <cmrmailboxutils.h>

#include "CMRUtilsUiServices.h"

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

enum TPanicCode

    {

    EPanicSessionSetupAlreadyDone = 1,

    EPanicMandatoryObserverMissing,

    EPanicMsvSessionExpected

    };

_LIT( KPanicMsg, "CMRUtilsImpl" );

void Panic( TPanicCode aReason )

    {

    User::Panic( KPanicMsg, aReason );

    }

}  // namespace

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

// MEMBER FUNCTIONS

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

//

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

// CMRUtilsImpl::NewL

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

//

CMRUtilsImpl* CMRUtilsImpl::NewL()

	{

	LOG("CMRUtilsImpl::NewL()");

	CMRUtilsImpl* self = new( ELeave ) CMRUtilsImpl();

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop();

	LOG("CMRUtilsImpl::NewL() -> End");	

	return self;

	}

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

// CMRUtilsImpl::CMRUtilsImpl

//

// Constructor.

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

//

CMRUtilsImpl::CMRUtilsImpl()

    : iCalEngStatus( MMRUtilsObserver::ENotReady )

    {    

    }

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

// CMRUtilsImpl::~CMRUtilsImpl

//

// Destructor.

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

//        

CMRUtilsImpl::~CMRUtilsImpl()

    {    

    delete iCalDbMgr;

    delete iUiServices;

    delete iMRMailboxUtils;

    }

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

// CMRUtilsImpl::ConstructL

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

//    

void CMRUtilsImpl::ConstructL()

    {

    // See also SessionSetupL() for construction phase functionality    

    }

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

// CMRUtilsImpl::EntryView

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

//

CCalEntryView* CMRUtilsImpl::EntryView()

    {

    if ( iCalEngStatus == EAvailable ||

         iCalEngStatus == EAvailableWithoutTombs )

        {

        return iCalDbMgr->NormalDbEntryView();

        }

    else

        {

        return NULL;

        }

    }

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

// CMRUtilsImpl::InstanceView

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

//

CCalInstanceView* CMRUtilsImpl::InstanceView()

    {

    if ( iCalEngStatus == EAvailable ||

         iCalEngStatus == EAvailableWithoutTombs )

        {

        return iCalDbMgr->NormalDbInstanceView();

        }

    else

        {

        return NULL;

        }

    }

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

// CMRUtilsImpl::FetchEntriesL

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

//  

void CMRUtilsImpl::FetchEntriesL(

    RPointerArray<CCalEntry>& aCalEntryArray,

    const CalCommon::TCalTimeRange& aTimeRange )

    {

    LeaveIfEngNotAvailableL();

    iCalDbMgr->FetchEntriesL( aCalEntryArray, aTimeRange );

    } 

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

// CMRUtilsImpl::FetchEntryL

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

//  

CCalEntry* CMRUtilsImpl::FetchEntryL(

    const TDesC8& aUid,

    const TCalTime& aRecurrenceId )

    {

    LeaveIfEngNotAvailableL();

    return iCalDbMgr->FetchEntryL( aUid, aRecurrenceId );

    }        

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

// CMRUtilsImpl::UpdateEntryL

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

//          

TInt CMRUtilsImpl::UpdateEntryL( const CCalEntry& aCalEntry )

    {

    LeaveIfEngNotAvailableL();

    return iCalDbMgr->UpdateEntryL( aCalEntry ); 

    }        

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

// CMRUtilsImpl::ResetTombsFileL

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

//          

void CMRUtilsImpl::ResetTombsFileL()

    {

    LeaveIfEngNotAvailableL();

    iCalDbMgr->ResetTombsFileL();

    }

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

// CMRUtilsImpl::DeleteTombstonesL

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

//          

void CMRUtilsImpl::DeleteTombstonesL(

    const CalCommon::TCalTimeRange& aCalTimeRange )

    {

    LeaveIfEngNotAvailableL();

    iCalDbMgr->DeleteTombstonesL( aCalTimeRange );

    }

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

// CMRUtilsImpl::StoreL

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

//          

MMRUtilsTombsExt::TMRUtilsDbResult CMRUtilsImpl::StoreL(

    CCalEntry& aCalEntry,

    TBool aResurrect )

    {

    LeaveIfEngNotAvailableL();          

    return iCalDbMgr->StoreEntryCondL( aCalEntry, aResurrect );

    }

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

// CMRUtilsImpl::CheckEntryCondL

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

//          

MMRUtilsTombsExt::TMRUtilsDbResult CMRUtilsImpl::CheckEntryCondL(

    const CCalEntry& aCalEntry )

    {

    LeaveIfEngNotAvailableL();

    // We want to keep const in CMRUtil API, but CalenInterimApi::StoreL()

    // takes non-const CCalEntry reference. With this method it is still

    // safe to cast away constness since in this case we are only performing

    // a check, not storing actually.

    CCalEntry& entry = const_cast<CCalEntry&>( aCalEntry );

    return iCalDbMgr->StoreEntryCondL( entry, EFalse, ETrue );

    }

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

// CMRUtilsImpl::DeleteL

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

//          

void CMRUtilsImpl::DeleteL( const TDesC8& aUid )

    {

    LeaveIfEngNotAvailableL();

    iCalDbMgr->DeleteEntryCondL( aUid );

    }

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

// CMRUtilsImpl::DeleteL

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

//          

void CMRUtilsImpl::DeleteL( const TCalLocalUid& aLocalUid )

    {

    LeaveIfEngNotAvailableL();

    iCalDbMgr->DeleteEntryCondL( aLocalUid );

    }

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

// CMRUtilsImpl::DeleteL

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

//          

void CMRUtilsImpl::DeleteL( const CCalEntry& aCalEntry )

    {

    LeaveIfEngNotAvailableL();

    iCalDbMgr->DeleteEntryCondL( aCalEntry );

    }

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

// CMRUtilsImpl::DeleteL

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

//          

void CMRUtilsImpl::DeleteL(

    const CalCommon::TCalTimeRange& aCalTimeRange )

    {

    LeaveIfEngNotAvailableL();

    iCalDbMgr->DeleteEntryCondL( aCalTimeRange );    

    }

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

// CMRUtilsImpl::DeleteWithUiL

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

//          

TInt CMRUtilsImpl::DeleteWithUiL( const CCalEntry& aEntry, TMsvId aMailbox )

    {

    LeaveIfEngNotAvailableL();

    LeaveIfUiExtNotAvailableL();

    return iUiServices->DeleteWithUiL( aEntry, aMailbox );

    }

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

// CMRUtilsImpl::DeleteWithUiL

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

//          

TInt CMRUtilsImpl::DeleteWithUiL( CCalInstance* aInstance, TMsvId aMailbox )

    {

    LeaveIfEngNotAvailableL();

    LeaveIfUiExtNotAvailableL();

    return iUiServices->DeleteWithUiL( aInstance, aMailbox );

    }

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

// CMRUtilsImpl::SendWithUiL

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

//  

void CMRUtilsImpl::SendWithUiL( const CCalEntry& aEntry, TMsvId aMailbox )

    {

    LeaveIfEngNotAvailableL();

    LeaveIfUiExtNotAvailableL();

    iUiServices->SendL( aEntry, aMailbox );

    }

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

// CMRUtilsImpl::RespondWithUiL

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

//                     

TInt CMRUtilsImpl::RespondWithUiL(

    const RPointerArray<CCalEntry>& aEntries,

    CCalAttendee::TCalStatus aStatus,

    TMsvId aMailbox )

    {

    LeaveIfEngNotAvailableL();

    LeaveIfUiExtNotAvailableL();

    return iUiServices->RespondWithUiL( aEntries, aStatus, aMailbox );    

    }

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

// CMRUtilsImpl::CancelWithUiL

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

// 

TInt CMRUtilsImpl::CancelWithUiL(

    const RPointerArray<CCalEntry>& aEntries,

    TMsvId aMailbox )

    {

    LeaveIfEngNotAvailableL();

    LeaveIfUiExtNotAvailableL();

    return iUiServices->CancelWithUiL( aEntries, aMailbox );    

    }

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

// CMRUtilsImpl::ReplyToL

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

// 

void CMRUtilsImpl::ReplyToL(

    TMailRecipients aRecipients,

    const CCalEntry& aCalEntry,

    const TDesC& aSenderAddr,

    TMsvId aMailbox )

    {

    LeaveIfEngNotAvailableL();

    LeaveIfUiExtNotAvailableL();

    iUiServices->ReplyToL( aRecipients, aCalEntry, aSenderAddr, aMailbox );    

    }

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

// CMRUtilsImpl::MailHeaderFromFieldLC

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

// 

HBufC* CMRUtilsImpl::MailHeaderFromFieldLC( TMsvId aMessage )

    {

    HBufC* fromField = NULL;

    if ( !iMsvSession )

        { // This method should only be called in case of opening from Mail,

          // -> valid MsvSession given by the client.

        __ASSERT_DEBUG( EFalse, Panic( EPanicMsvSessionExpected ) );

        User::Leave( KErrNotSupported );

        }

    else

        {

        TMsvId dummy( KMsvNullIndexEntryId );

        TMsvEntry entry;

        User::LeaveIfError( iMsvSession->GetEntry( aMessage, dummy, entry ) );        

        fromField = entry.iDetails.AllocLC();

        }

    return fromField;

    }

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

// CMRUtilsImpl::MailHeaderSubjectFieldLC

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

// 

HBufC* CMRUtilsImpl::MailHeaderSubjectFieldLC( TMsvId aMessage )

    {

    HBufC* subjectField = NULL;

    if ( !iMsvSession )

        { // This method should only be called in case of opening from Mail,

          // -> valid MsvSession given by the client.

        __ASSERT_DEBUG( EFalse, Panic( EPanicMsvSessionExpected ) );

        User::Leave( KErrNotSupported );

        }

    else

        {

        TMsvId dummy( KMsvNullIndexEntryId );

        TMsvEntry entry;

        User::LeaveIfError( iMsvSession->GetEntry( aMessage, dummy, entry ) );        

        subjectField = entry.iDescription.AllocLC();

        }

    return subjectField;    

    }

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

// CMRUtilsImpl::ExtensionL

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

//

TAny* CMRUtilsImpl::ExtensionL( TUid aExtensionUid )

    {

    if ( aExtensionUid == MMRUtilsTombsExt::ExtensionUid() )

        {

        return static_cast<MMRUtilsTombsExt*>( this );

        }

    else

        {        

        return NULL;

        }

    }

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

// CMRUtilsImpl::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.

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

//          

void CMRUtilsImpl::SessionSetupL( 

    CCalSession& aCalSession, 

    CMsvSession* aMsvSession )

    {                    

    LOG("CMRUtilsImpl::SessionSetupL()");

    iCalSession = &aCalSession;

    iMsvSession = aMsvSession;   

    LOG("CMRUtilsImpl::SessionSetupL(), creating mailbox utils");

    iMRMailboxUtils = CMRMailboxUtils::NewL( aMsvSession );    

    // This will remain null if no ui environment is available

    LOG("CMRUtilsImpl::SessionSetupL(), creating ui services");    

    iUiServices = MRUtilsFactory::CreateUiServicesL( *this,

                                                     *iCalSession,

                                                     iMsvSession,

                                                     *iMRMailboxUtils );    

    // Asynchronous initialization of CMRUtilsCalDbMgr:     

    LOG("CMRUtilsImpl::SessionSetupL(), creating db mgr");           

    iCalDbMgr = MRUtilsFactory::CreateCalDbMgrL( *iCalSession, *this );    

    LOG("CMRUtilsImpl::SessionSetupL() -> End");    

    }

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

// CMRUtilsImpl::HandleCalEngStatus

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

//    

void CMRUtilsImpl::HandleCalEngStatus( TMRUtilsCalEngStatus aStatus )

    {

    iCalEngStatus = aStatus;

    __ASSERT_DEBUG( iObserver, EPanicMandatoryObserverMissing );

    iObserver->HandleCalEngStatus( iCalEngStatus );

    }

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

// CMRUtilsImpl::HandleOperation

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

//    

void CMRUtilsImpl::HandleOperation(

    TInt aType,

    TInt aPercentageCompleted, 

    TInt aStatus )

    {

    iObserver->HandleOperation( aType, aPercentageCompleted, aStatus );

    }    

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

// CMRUtilsImpl::LeaveIfEngNotAvailableL

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

//

void CMRUtilsImpl::LeaveIfEngNotAvailableL() const

    {

    if ( iCalEngStatus == MMRUtilsObserver::ENotReady )

        {

        User::Leave( KErrNotReady );

        }

    else if ( iCalEngStatus == MMRUtilsObserver::ENotAvailable )

        {

        User::Leave( KErrCouldNotConnect );

        }

    }

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

// CMRUtilsImpl::LeaveIfEngNotAvailableL

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

//

void CMRUtilsImpl::LeaveIfUiExtNotAvailableL() const

    {

    if ( !iUiServices )

        {

        User::Leave( KErrNotSupported );

        }

    }

// End of file