/*

* 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 model base 

*

*/

// INCLUDE FILES

#include "CMRModelBase.h"

#include "MRHelpers.h"

#include "ICalUILog.h"

#include "MREntryConsultant.h"

#include "CMRUtilsInternal.h"

#include "MRViewersPanic.h" 					//panic codes

#include "meetingrequestviewers.hrh" 	        //common constants

#include "ProcessingStructs.h" 					//scenario structures for meeting request processing

#include "CMRProcessor.h"

#include "CMRInfoPopup.h"

#include <e32std.h>

#include <calentry.h> 		//CCalEntry (Calendar entry API V2)

#include <caluser.h> 		//caluser and attendee 

#include <calalarm.h>

#include <MsgMailUIDs.h> 	//uid for mail application

#include <cemailaccounts.h>

#include <smtpset.h>

#include <imapset.h>

#include <eikenv.h>

#include <pop3set.h>

#include <MuiuMsvUiServiceUtilities.h> 

#include <SendUiConsts.h> 						//mailbox uids

#include <stringloader.h> 						//loading of string resources

#include <meetingrequestviewersuires.rsg> 			//resource definitions header

#include <cmrmailboxutils.h>

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

_LIT( KPanicMsg, "CMRModelBase" );

void Panic( TPanicCode aReason )

    {

    User::Panic( KPanicMsg, aReason );

    }

}  // namespace

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

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

// ?classname::?classname

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMRModelBase::CMRModelBase(

    CMRMailboxUtils& aMailboxMRUtils,

    CMRUtilsInternal& aMRUtils,

    const MAgnEntryUi::TAgnEntryUiInParams& aInParams )

    : iMRUtils( aMRUtils ),

      iMRMailboxUtils(aMailboxMRUtils),

      iInParams( aInParams ),

      iIsEntryEdited( EFalse )

    {

    }

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

// ?classname::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMRModelBase::ConstructL( RPointerArray<CCalEntry>& aEntries )

    {

    LOG("CMRHandler::ConstructL, creating processor");    

    iMRProcessor = CMRProcessor::NewL( iMRMailboxUtils,

                                       iMRUtils,

                                       iInParams,

                                       aEntries );

    LOG("CMRHandler::ConstructL, processing entries");

    iMRProcessor->ProcessEntriesL();    

    }

// Destructor

CMRModelBase::~CMRModelBase()

    {

    delete iMRProcessor;

    }

CCalEntry::TMethod CMRModelBase::MethodL()

	{

	return CombinedEntry()->MethodL();

	}

MMRInfoPopup* CMRModelBase::CreateInfoPopupL()

    {

    TBool mode( iInParams.iEditorMode ==

        MAgnEntryUi::EViewEntry ? ETrue : EFalse );

    return CMRInfoPopup::NewL( CEikonEnv::Static(),

                               iMRMailboxUtils,

                               *( CombinedEntry() ),

                               mode );

    }

TBool CMRModelBase::IsCmdAvailable( TInt aCommandId )

    {

    TInt retVal( EFalse );

    TRAP_IGNORE( retVal = IsCmdAvailableL( aCommandId ) );

    // command not available in case of error

    return retVal;

    }

TBool CMRModelBase::IsCmdAvailableL( TInt aCommandId )

    {

    TInt retVal( EFalse );

    switch ( aCommandId )

        {

        case EMRCommandDisableAlarm:

            {

            retVal = CanDisableAlarmL();

            break;

            }

        case EMRCommandAttachments:

            {

            retVal = CanShowAttachmentsL();

            break;

            }

        case EMRCommandMessageDetails:

            {

            retVal = CanShowInfoL();            

            break;

            }

        case EMRCommandRetrieve:

            {

            retVal = CanRetrieveL();            

            break;

            }

        case EMRCommandSaveFromFile:

            {

            retVal = CanSaveFromFileL();

            break;

            }

        default:

            {

            retVal = EFalse;

            break;

            }                                     

        }

    return retVal;

    }

HBufC* CMRModelBase::MailboxOpeningNoteL()

	{

	TInt resource( -1 );

	if ( MREntryConsultant::IsCancelledL( *CombinedEntry(), iMRMailboxUtils ) )

		{

		resource = R_QTN_CALE_MEETING_IS_CANCELLED;

		}

	else if ( iMRProcessor->ProcessingDbResult() ==

	            MMRUtilsTombsExt::EErrorObsolete )

		{

		resource = R_QTN_CALE_MEETING_IS_OUT_OF_DATE;

		}

    // other error cases:

	else if ( iMRProcessor->ProcessingDbResult() <= ENullOp )

		{

		resource = R_QTN_CALE_MEETING_IS_CORRUPTED;

		}

    else

        {

        return NULL;

        }

	return StringLoader::LoadL( resource, CCoeEnv::Static() );

	}

MMRModelInterface::TEditingMode CMRModelBase::EditingMode() const

    {

    return iMRProcessor->EditingMode();

    }

void CMRModelBase::SetEditingModeL( MMRModelInterface::TEditingMode aEditMode )

    {

    iMRProcessor->SetEditingModeL( aEditMode );

    }

void CMRModelBase::SetEntryEdited()

    {

    iIsEntryEdited = ETrue;

    }

TBool CMRModelBase::IsEntryEdited()

    {

    return iIsEntryEdited;    

    }

TBool CMRModelBase::CanDisableAlarmL()

	{

	TBool retVal( EFalse );

	const CCalEntry& entry = *( CombinedEntry() );

	if ( IsEntryUsableL( entry ) )

		{

		CCalAlarm* alarm = entry.AlarmL(); // ownership transferred		

		if ( alarm )

		    {

		    delete alarm;

			retVal = ETrue;

		    }

		else

		    {		    

			retVal = EFalse;

		    }

		}

    return retVal;

	}	

TBool CMRModelBase::CanShowAttachmentsL()

	{	

	if ( iInParams.iCallingApp.iUid == KUidMailApplication )

		{

		return ETrue;

		}

    else

        {

        return EFalse;

        }

	}

TBool CMRModelBase::CanShowInfoL()

	{

	if ( iInParams.iCallingApp.iUid == KUidMailApplication )

		{

        return ETrue;

		}

    else

        {

        return EFalse;

        }

	}

TBool CMRModelBase::CanRetrieveL()

	{

	if ( iInParams.iCallingApp.iUid == KUidMailApplication )

		{

        return ETrue;

		}

    else

        {

        return EFalse;

        }

	}

TBool CMRModelBase::CanSaveFromFileL()

	{

	const CCalEntry& entry = *( CombinedEntry() );

	// allow storing cancelled request to db

	// -> IsEntryUsableL 2nd param == ETrue

	// check if exactly identical entry exists in db

	// -> ExistsInDbL 3rd param == ETrue

	if ( iInParams.iCallingApp.iUid == KUidBVAApplication &&

	     IsEntryUsableL( entry, ETrue ) &&

	     !MREntryConsultant::ExistsInDbL( entry, iMRUtils, ETrue ) )

		{

        return ETrue;

		}

    else

        {

        return EFalse;

        }

	}

CCalEntry* CMRModelBase::CombinedEntry()

	{

	return iMRProcessor->CombinedEntry();

	}

void CMRModelBase::RefreshViewableEntryL()

    {

    iMRProcessor->RefreshViewableEntryL();

    }

TBool CMRModelBase::IsSenderOrganizerL()

    {

    __ASSERT_DEBUG( iInParams.iCallingApp.iUid == KUidMailApplication,

                    Panic( EIllegalCallerApp ) );

    __ASSERT_DEBUG( iInParams.iMsgSession,

                    Panic( EMsvSessionNull ) );

    __ASSERT_DEBUG( iInParams.iMessageId != KMsvNullIndexEntryId,

                    Panic( ETMsvIDNull ) );

    TBool retVal( EFalse );

    CCalUser* organizer = CombinedEntry()->OrganizerL();

    if ( organizer )

        {

        HBufC* senderAddr = MRHelpers::SenderAddressLC(

            *( iInParams.iMsgSession ),

            iInParams.iMessageId,

            ETrue );

        TPtrC organizerAddr =

            MRHelpers::AddressWithoutMailtoPrefix( organizer->Address() );

        if ( senderAddr->CompareF( organizerAddr ) == 0 )

            {

            retVal = ETrue;

            }

        CleanupStack::PopAndDestroy( senderAddr );

        }

    return retVal;

    }

TBool CMRModelBase::MailHeadersAvailable()

    {

    return ( iInParams.iMessageId != KMsvNullIndexEntryId );

    }

HBufC* CMRModelBase::MailHeaderFromFieldLC()

	{

	return iMRUtils.MailHeaderFromFieldLC( iInParams.iMessageId );

	}

HBufC* CMRModelBase::MailHeaderSubjectFieldLC()

	{

	return iMRUtils.MailHeaderSubjectFieldLC( iInParams.iMessageId );

	}

TBool CMRModelBase::IsEntryUsableL(

    const CCalEntry& aEntry,

    TBool aAllowCancelled )

    {

    TBool retVal( EFalse );

    if ( iMRProcessor->ProcessingResultOp() > ENullOp &&

         !MREntryConsultant::IsEntryOutOfDateL( aEntry ) )

        {

        if ( aAllowCancelled || 

             !MREntryConsultant::IsCancelledL( aEntry, iMRMailboxUtils ) )

            {            

            retVal = ETrue;

            }

        }

    return retVal;

    }

TBool CMRModelBase::IsSendableL( const CCalEntry& aEntry )

    {

    TBool retVal( EFalse );

    if ( IsEntryUsableL( aEntry ) )

        {        

        RPointerArray<CCalAttendee>& attendees = aEntry.AttendeesL();

        TInt count( attendees.Count() );    

        for ( TInt i( 0 ); i < count; ++i )

            {

            if ( attendees[i]->StatusL() != CCalAttendee::EDeclined )

                { // there exists at least one attendee to send to

                retVal = ETrue;

                break;

                }

            }

        }

    return retVal;

    }

//  End of File