/*

* 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 MR Entry implementation

*

*/

// INCLUDE FILES

#include "cesmrmeetingrequestentry.h"

#include "cesmrfsmailboxutils.h"

#include "cesmrcaldbmgr.h"

#include "esmrhelper.h"

#include "esmrentryhelper.h"

#include "cesmrconflictchecker.h"

#include "cesmrcaluserutil.h"

#include "esmrconfig.hrh"

#include <esmralarminfo.rsg>

#include <calentry.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <caluser.h>

#include <cmrmailboxutils.h>

#include <calrrule.h>

#include <data_caging_path_literals.hrh>

#include <coemain.h>

#include <calentryview.h>

#include <ct/rcpointerarray.h>

/// Unnamed namespace for local definitions

namespace {

// Alarm resource file location

_LIT( KAlarmInfoResource, "esmralarminfo.rsc" );

// Definition for default alarm time for meeting

const TInt KDefaultMeetingAlarmMinutes( 15 );

_LIT( KReplaceLineFeedChar, "\n" );

_LIT( KLineFeed, "\x2029");

/**

 */

        CCalEntry& aEntry )

    {

    }

#ifdef _DEBUG

// Definition for panic text

_LIT( KESMREntryPanicTxt, "ESMRMeetingRequestEntry" );

/**

 * ES MR Entry panic codes

 */

enum TESMRMeetingRequestEntry

    {

    EESMREntryNotExist = 1, // Entry does not exist

    EESMRInvalidRole,       // Phone owner has invalid role

    EESMRNoInfoObjectAttendeeFound,

    EESMRPhoneOwnerNotSet,

    EESMRRecurrenceError,

    EESMRInvalidReplyType,

    EESMRInvalidInvalidAttendeeStatus,

    EESMRParentNotFound

    };

/**

 * Raises panic.

 * @param aPanic Panic code

 */

void Panic(TESMRMeetingRequestEntry aPanic)

    {

    User::Panic( KESMREntryPanicTxt, aPanic);

    }

#endif // _DEBUG

}  // namespace

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

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

// CESMRMeetingRequestEntry::CESMRMeetingRequestEntry

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

//

inline CESMRMeetingRequestEntry::CESMRMeetingRequestEntry(

        CMRMailboxUtils& aMRMailboxUtils,

        MESMRCalDbMgr& aCalDb,

        TBool aConflictsExists,

        TESMRInputParams* aESMRInputParams )

:   iMRMailboxUtils( aMRMailboxUtils ),

    iConflictsExists( aConflictsExists),

    iCalDb( aCalDb ),

    {

    FUNC_LOG;

    // Not yet implementation

    }

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

// CESMRMeetingRequestEntry::~CESMRMeetingRequestEntry

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

//

    {

    FUNC_LOG;

    delete iEntry;

    delete iForwardEntry;

    delete iOrginalEntry;

    delete iParameterEntry;

    }

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

// CESMRMeetingRequestEntry::NewL

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

//

        const CCalEntry& aEntry,

        CMRMailboxUtils& aMRMailboxUtils,

        MESMRCalDbMgr& aCalDb,

        TBool aConflictsExists,

        TESMRInputParams* aESMRInputParams )

    {

    FUNC_LOG;

    CESMRMeetingRequestEntry* self =

            new (ELeave) CESMRMeetingRequestEntry(

                aMRMailboxUtils,

                aCalDb,

                aConflictsExists,

                aESMRInputParams );

    CleanupStack::PushL( self );

    self->ConstructL( aEntry );

    CleanupStack::Pop( self );

    return self;

    }

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

// CESMRMeetingRequestEntry::ConstructL

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

//

void CESMRMeetingRequestEntry::ConstructL(

        const CCalEntry& aEntry )

    {

    FUNC_LOG;

    if ( EESMRRoleOrganizer == RoleL() && IsStoredL() )

        {

        // Increase sequence number

        TInt seqNo( iEntry->SequenceNumberL() + 1);

        iEntry->SetSequenceNumberL( seqNo );

        iOrginalEntry->SetSequenceNumberL( seqNo );

        }

    CCalEntry::TMethod method( iEntry->MethodL() );

    if ( CCalEntry::EMethodNone == method )

        {

        iEntry->SetMethodL( CCalEntry::EMethodRequest );

        iOrginalEntry->SetMethodL( CCalEntry::EMethodRequest );

        }

    HBufC* newDescription = ReplaceCharactersFromBufferLC(

                                    KReplaceLineFeedChar(),

                                    KLineFeed() );

    iEntry->SetDescriptionL( *newDescription );

    CleanupStack::PopAndDestroy( newDescription );

    }

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

// CESMRMeetingRequestEntry::ReplaceCharactersFromBufferL

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

//

                              const TDesC& aReplacement )

    {

    FUNC_LOG;

    HBufC* newBuffer = aTarget.AllocLC();

    TPtr16 ptr = newBuffer->Des();

    // find next occurance:

    TInt offset = ptr.Find(aFindString);

    while ( offset != KErrNotFound )

        {

        // replace the data:

        ptr.Replace( offset, aFindString.Length(), aReplacement);

        // find next occurance:

        offset = ptr.Find(aFindString);

        }

    return newBuffer;

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

// CESMRMeetingRequestEntry::Type

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

//

MESMRCalEntry::TESMRCalEntryType CESMRMeetingRequestEntry::Type() const

    {

    FUNC_LOG;

    // This is meeting request

    return MESMRCalEntry::EESMRCalEntryMeetingRequest;

    }

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

// CESMRMeetingRequestEntry::MESMRCalEntryRef

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

//

MESMRCalEntry& CESMRMeetingRequestEntry::MESMRCalEntryRef()

    {

    FUNC_LOG;

    return *this;

    }

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

// CESMRMeetingRequestEntry::MESMRCalEntryRef

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

//

const MESMRCalEntry& CESMRMeetingRequestEntry::MESMRCalEntryRef() const

    {

    FUNC_LOG;

    return *this;

    }

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

// CESMRMeetingRequestEntry::Entry

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

//

CCalEntry& CESMRMeetingRequestEntry::Entry()

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

    if ( iForwardEntry )

        {

        return *iForwardEntry;

        }

    return *iEntry;

    }

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

// CESMRMeetingRequestEntry::Entry

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

//

const CCalEntry& CESMRMeetingRequestEntry::Entry() const

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

    if ( iForwardEntry )

        {

        return *iForwardEntry;

        }

    return *iEntry;

    }

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

// CESMRMeetingRequestEntry::InstanceL

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

//

CCalInstance* CESMRMeetingRequestEntry::InstanceL() const

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

    __ASSERT_DEBUG( iOrginalEntry, Panic(EESMREntryNotExist ) );

    CCalInstance* instance = NULL;

    if ( !instance )

        {

        // Instance not found by using the edited entry

        // Trying with orginal.

        }

    if ( !instance )

        {

        // Instance not found by using edited or orginal entry.

        // --> Leave

        User::Leave( KErrNotFound );

        }

    return instance;

    }

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

// CESMRMeetingRequestEntry::CanSetRecurrenceL

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

//

TBool CESMRMeetingRequestEntry::CanSetRecurrenceL() const

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

    TBool canSetRecurrence( ETrue );

    if ( iEntry->EntryTypeL() == CCalEntry::EAppt &&

            ESMREntryHelper::IsRepeatingMeetingL(*iEntry) &&

        (!ESMREntryHelper::IsModifyingEntryL(*iEntry) &&

          MESMRCalEntry::EESMRThisOnly == iRecurrenceModRule ))

        {

        canSetRecurrence = EFalse;

        }

    return canSetRecurrence;

    }

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

// CESMRMeetingRequestEntry::IsRecurrentEventL

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

//

TBool CESMRMeetingRequestEntry::IsRecurrentEventL() const

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

    TBool recurrenceEvent( EFalse );

    if ( IsStoredL() )

        {

        // Entry is stored in calendar db

        // Lets look recurrence using instance

        // Ownership is transferred

        CCalInstance* instance = NULL;

        TRAPD(err, instance = InstanceL() );

            {

            User::LeaveIfError( err );

            }

        if ( instance )

            {

            CleanupStack::PushL( instance );

            CCalEntry& instanceParentEntry = instance->Entry();

            if ( ESMREntryHelper::IsRepeatingMeetingL( instanceParentEntry ) )

                {

                recurrenceEvent = ETrue;

                }

            CleanupStack::PopAndDestroy( instance );

            }

        else if ( ESMREntryHelper::IsRepeatingMeetingL( *iEntry ) )

            {

            recurrenceEvent = ETrue;

            }

        }

    else

        {

        // Entry is not stored in calendar db

        if ( ESMREntryHelper::IsRepeatingMeetingL( *iEntry ) )

            {

            // This is repeating meeting

            recurrenceEvent = ETrue;

            }

        }

    return recurrenceEvent;

    }

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

// CESMRMeetingRequestEntry::SetRecurrenceL

//

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

//

void CESMRMeetingRequestEntry::SetRecurrenceL(

        TESMRRecurrenceValue aRecurrence,

        TTime aUntil )

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

    // Check if this entry's recurrence can be edited

    if ( !CanSetRecurrenceL() )

        {

        User::Leave( KErrNotSupported );

        }

    if ( aRecurrence != ERecurrenceNot &&

            MESMRCalEntry::EESMRAllInSeries != iRecurrenceModRule )

        {

        // Make sure that mod rule is correct

        SetModifyingRuleL(

                MESMRCalEntry::EESMRAllInSeries );

        }

    CESMRRecurrenceInfoHandler* recurrenceHandler =

            CESMRRecurrenceInfoHandler::NewLC( *iEntry );

    recurrenceHandler->SetRecurrenceL( aRecurrence, aUntil );

    CleanupStack::PopAndDestroy( recurrenceHandler );

    }

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

// CESMRMeetingRequestEntry::GetRecurrenceL

//

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

//

void CESMRMeetingRequestEntry::GetRecurrenceL(

        TESMRRecurrenceValue& aRecurrence,

        TTime& aUntil) const

    {

    FUNC_LOG;

    __ASSERT_DEBUG( iEntry, Panic(EESMREntryNotExist ) );

    CESMRRecurrenceInfoHandler* recurrenceHandler =

    recurrenceHandler->GetRecurrenceL( aRecurrence, aUntil );

    CleanupStack::PopAndDestroy( recurrenceHandler );

    }

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

// CESMRMeetingRequestEntry::RecurrenceModRule

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

//

MESMRCalEntry::TESMRRecurrenceModifyingRule

    CESMRMeetingRequestEntry::RecurrenceModRule() const

    {

    return iRecurrenceModRule;

    }