/*

* 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:   CXcapReplacement

*

*/

// INCLUDES

#include "XcapAppUsage.h"

#include "XcapDocument.h"

#include "XcapUriParser.h"

#include "XdmXmlParser.h"

#include "XcapHttpReqPut.h"

#include "XcapReplacement.h"

#include "XcapHttpReqDelete.h"

#include "XcapHttpTransport.h"

#include "XcapHttpOperation.h"

#include "XdmNodeAttribute.h"

#include "XcapEngineDefines.h"

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

// C++ constructor can NOT contain any code, that might leave.

//

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

//

CXcapReplacement::CXcapReplacement( CXcapDocument& aParentDoc,

                                    CXcapDocumentNode* aOldNode,

                                    CXcapDocumentNode* aNewNode,

                                    CXcapOperationFactory& aOperationFactory ) :

                                    CXcapHttpOperation( aParentDoc, aOldNode, aOperationFactory ),

                                    iNewNode( ( CXcapDocumentNode* )aNewNode ),

                                    iOperationType( aOldNode == NULL ?

                                    EXdmDocument : EXdmPartialDocument )

    {

    }

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

// Two-phased constructor.

//

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

//

CXcapReplacement* CXcapReplacement::NewL( CXcapDocument& aParentDoc,

                                          CXcapDocumentNode* aOldNode,

                                          CXcapDocumentNode* aNewNode,

                                          CXcapOperationFactory& aOperationFactory )

    {

    CXcapReplacement* self = new ( ELeave ) CXcapReplacement( aParentDoc, aOldNode, aNewNode, aOperationFactory );

    CleanupStack::PushL( self );

    self->BaseConstructL();

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CXcapReplacement::ConstructL

//

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

//

void CXcapReplacement::ConstructL()

    {

    CXcapHttpReqPut* request = Transport().PutL( iTargetDoc.Name() );

    CleanupStack::PushL( request );

    User::LeaveIfError( iRequestQueue.Append( request ) );

    request->SetExpiryTimeL( NULL, KDefaultHttpRequestTimeout * 1000000 );

    CleanupStack::Pop();  //request

    //If they point to the same node, we're dealing with a complete document

    if( iDocumentSubset != NULL && iTargetDoc.DocumentRoot() != iDocumentSubset )

        iUriParser->SetDocumentSubset( iDocumentSubset );

    }

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

// CXcapReplacement::FormatModRequestL

//

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

//

TInt CXcapReplacement::FormatModRequestL( const CXcapDocumentNode* aDocumentNode )

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapReplacement::FormatModRequestL()" ) );

        iOperationFactory.WriteToLog( _L8( "  Operation type:  %d" ), iOperationType );

        iOperationFactory.WriteToLog( _L8( "  Document subset: %x" ), iDocumentSubset );

    #endif

    return CXcapHttpOperation::FormatModRequestL( aDocumentNode );   

    }

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

// CXcapReplacement::ExecuteL

//

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

//

void CXcapReplacement::ExecuteL()

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapReplacement::ExecuteL()" ) );  

    #endif

    User::LeaveIfError( FormatModRequestL( iNewNode ) );

    if( iOperationType == EXdmPartialDocument )

        {

        TPtrC8 eTag = iTargetDoc.ETag();

        if( eTag.Length() > 0 )

            iActiveRequest->SetHeaderL( KHttpHeaderIfMatch, eTag );

        //If they match semantically, there's no need for DELETE operation

        if( iDocumentSubset->Match( *iNewNode ) )

            iOperationPhase = EHttpPutting;

        else

            {

            CXcapHttpReqDelete* request = Transport().DeleteL( iTargetDoc.Name() );

            CleanupStack::PushL( request );

            User::LeaveIfError( iRequestQueue.Insert( request, 0 ) );

            CleanupStack::Pop();  //request

            if( eTag.Length() > 0 )

                request->SetHeaderL( KHttpHeaderIfMatch, eTag );

            request->SetHeaderL( KHttpHeaderAccept, _L8( "application/xcap-diff+xml" ) );

            iActiveRequest = request;

            iOperationPhase = EHttpDeleting;

            }

        TRAPD( error, iUriParser->ParseL( iActiveRequest->RequestUriL() ) );

        if( error == KErrNone )

            {

            TPtrC8 uri = iUriParser->DesC8();

            #ifdef _DEBUG

                iOperationFactory.WriteToLog( _L8( " New URI: %S" ), &uri );  

            #endif

            HBufC8* escape = CXcapHttpOperation::EscapeLC( uri );

            iActiveRequest->UpdateRequestUriL( escape->Des() );

            CleanupStack::PopAndDestroy();  //escape

            }

        }

    else

        {

        }

    }

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

// CXcapReplacement::OperationCompleteL

//

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

//

void CXcapReplacement::OperationCompleteL()

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog(

            _L8( "CXcapReplacement::OperationCompleteL() - Phase: %d" ), iOperationPhase );  

    #endif

    switch( iOperationPhase )

        {

        case EHttpDeleting:

            break;

        case EHttpPutting:

            break;

        default:

            iCompleted = ETrue;

            break;

        }

    }

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

// CXcapReplacement::OperationFailedL

//

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

//

void CXcapReplacement::OperationFailedL()

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapReplacement::OperationFailedL() - Error: %d" ),

                                        iStatus.Int() );

        TInt httpStatus = iRequestData == NULL ? KErrUnknown :

                          iRequestData->iHttpStatus;

    #endif

    switch( iOperationPhase )

        {

        case EHttpDeleting:

            #ifdef _DEBUG

                iOperationFactory.WriteToLog(

                    _L8( "DELETE failed - Error: %d  Status: %d" ), iStatus.Int(), httpStatus );  

            #endif

            break;

        case EHttpPutting:

            #ifdef _DEBUG

                iOperationFactory.WriteToLog(

                    _L8( "PUT failed - Error: %d  Status: %d" ), iStatus.Int(), httpStatus );  

            #endif

            break;

        default:

            break;

        }

    iResult = iStatus.Int();

    iCompleted = ETrue;   

    }

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

// CXcapReplacement::Result

//

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

//

TBool CXcapReplacement::Result() const

    {

    return ETrue;

    }

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

// CXcapReplacement::~CXcapReplacement

//

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

//

CXcapReplacement::~CXcapReplacement()

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapReplacement::~CXcapReplacement()" ) );  

    #endif

    }

//  End of File