/*

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

*

*/

// INCLUDES

#include "XcapCache.h"

#include "XcapAppUsage.h"

#include "XcapProtocol.h"

#include "XcapDocument.h"

#include "XcapAddition.h"

#include "XdmXmlParser.h"

#include "XcapUriParser.h"

#include "CommonDefines.h"

#include "XcapHttpReqPut.h"

#include "XcapHttpOperation.h"

#include "XcapHttpTransport.h"

#include "XcapOperationFactory.h"

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

// CXcapAddition::CXcapAddition

//

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

//

CXcapAddition::CXcapAddition( CXcapDocument& aParentDoc,

                              CXcapDocumentNode* aDocumentSubset,

                              CXcapOperationFactory& aOperationFactory ) :

                              CXcapHttpOperation( aParentDoc, aDocumentSubset, aOperationFactory ),

                              iOperationType( aDocumentSubset == NULL ?

                              EXdmDocument : EXdmPartialDocument )

    {

    }

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

// CXcapAddition::NewL

//

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

//

CXcapAddition* CXcapAddition::NewL( CXcapDocument& aParentDoc,

                                    CXcapDocumentNode* aDocumentSubset,

                                    CXcapOperationFactory& aOperationFactory )

    {

    CXcapAddition* self = new ( ELeave ) CXcapAddition( aParentDoc, aDocumentSubset, aOperationFactory );

    CleanupStack::PushL( self );

    self->BaseConstructL();

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CXcapAddition::ConstructL

//

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

//

void CXcapAddition::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 );

    }

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

// CXcapAddition::FormatModRequestL

//

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

//

TInt CXcapAddition::FormatModRequestL( const CXdmDocumentNode* aDocumentNode )

    {

    #ifdef _DEBUG

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

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

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

    #endif

    TInt validation = CXcapHttpOperation::FormatModRequestL( aDocumentNode );

    if( validation == KErrNone )

        {

        //Then set the properties particular to this type of request

        iOperationType = DetermineOperationType();

        if( iOperationType == EXdmDocument )

            iActiveRequest->SetHeaderL( KHttpHeaderContentType, iTargetDoc.ApplicationUsage().ContentType() );

        }

    else

        {

        #ifdef _DEBUG

            iOperationFactory.WriteToLog( _L8( " AppUsage reported the following error: %d" ), validation );

        #endif

        }

    return validation;

    }

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

// CXcapAddition::DetermineOperationType

//

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

//

TXdmOperationType CXcapAddition::DetermineOperationType()

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapAddition::DetermineDocType()" ) );

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

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

        iOperationFactory.WriteToLog( _L8( "  Document root:   %x" ), iTargetDoc.DocumentRoot() ); 

    #endif

    return iOperationType == EXdmDocument || ( EXdmPartialDocument &&

                             iDocumentSubset == iTargetDoc.DocumentRoot() ) ?

                             EXdmDocument : EXdmPartialDocument;

    }

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

// CXcapAddition::ExecuteL

//

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

//

void CXcapAddition::ExecuteL()

    {

    #ifdef _DEBUG

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

    #endif

    CXcapHttpOperation::ExecuteL( iActiveRequest, iDocumentSubset );

    }

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

// CXcapAddition::OperationCompleteL

//

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

//

void CXcapAddition::OperationCompleteL()

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapAddition::OperationCompleteL()" ) );  

    #endif

    TPtrC8 root = Transport().RootUri();

    iRequestData = iActiveRequest->ResponseData();

    TPtrC name = iTargetDoc.Name();

    switch( iRequestData->iHttpStatus )

        {

        case 200:           //Replaced, the document was already there

        case 201:           //"Created" -> Put operation was successful

            {

            #ifdef _DEBUG

                iOperationFactory.WriteToLog( _L8( " Status %d" ), iRequestData->iHttpStatus );  

            #endif

            iResult = KErrNone;

            TPtrC8 eTag = Descriptor( iRequestData->iETag );

            iTargetDoc.SetETag( eTag );

            RXcapCache* cache = iTargetDoc.Protocol().Cache();

            if( cache != NULL )

                {

                CXcapHttpContSupplier* request = ( CXcapHttpContSupplier* )iActiveRequest;

                TPtrC8 payload = request->RequestBody();

                iOperationType == EXdmDocument ? cache->Store( eTag, name, root, payload ) :

                                                 UpdatePartialToCacheL( cache, payload );

                }

            iCompleted = ETrue;

            }

            break;

        default:

            #ifdef _DEBUG

                iOperationFactory.WriteToLog( _L8( " Default case - Status: %d" ),

                                                   iRequestData->iHttpStatus ); 

            #endif

            TInt status = iRequestData->iHttpStatus;

            iResult = ReinterpretStatus( status );

            iCompleted = ETrue;

            break;

        }

    }

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

// CXcapAddition::UpdatePartialToCacheL

//

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

//

void CXcapAddition::UpdatePartialToCacheL( RXcapCache* aCache, const TDesC8& aNewData )

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapAddition::UpdatePartialToCacheL()" ) );  

    #endif

    HBufC8* newData = NULL;

    TPtrC name = iTargetDoc.Name();

    TPtrC8 root = Transport().RootUri();

    if( iOptionFlags & KFetchMasterFromCache )

        {

        TInt length = iTargetDoc.DataLength();

        //Do nothing, if the document is not in cache

        if( length > 0 )

            {

            HBufC8* data = HBufC8::NewLC( length );

            TPtr8 desc( data->Des() );

            aCache->FetchDocumentContent( desc, name, root );

            CXcapDocument* copy = iTargetDoc.TempCopyL();

            CleanupStack::PushL( copy );

            iXmlParser->ParseDocumentL( copy, desc );

            RPointerArray<CXdmDocumentNode> array;

            CleanupClosePushL( array );

            copy->Find( *iDocumentSubset, array );

            //If the element the subset points to is not present

            //in the original document, the new data must be

            //appended to the the subset element parent, instead.

            CXdmDocumentNode* node = array.Count() > 0 ?

                iDocumentSubset : iDocumentSubset->Parent();

            newData = iXmlParser->FormatToXmlLC( aNewData, copy, node );

            CleanupStack::Pop();  //newData

            CleanupStack::PopAndDestroy( 3 );  //array, tempCopy, data

            CleanupStack::PushL( newData );

            }           

        }

    else

        {

        CXdmDocumentNode* root = iTargetDoc.DocumentRoot();

        newData = iXmlParser->FormatToXmlLC( ETrue, &iTargetDoc, root );

        }

    if( newData )

        {

        aCache->Store( iTargetDoc.ETag(), name, root, newData->Des() );

        CleanupStack::PopAndDestroy();  //newData

        }

    }

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

// CXcapAddition::OperationFailedL

//

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

//

void CXcapAddition::OperationFailedL()

    {

    #ifdef _DEBUG

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

                                           iStatus.Int() );  

    #endif

    if( iStatus.Int() >= KErrNone )

        {

        TInt status = iActiveRequest->ResponseData()->iHttpStatus;

        TInt completion = iActiveRequest->ResponseData()->iCompletion;

        iResult = status < KErrNone || completion < KErrNone ? status : ReinterpretStatus( status );

        }

    else iResult = iStatus.Int();

    iCompleted = ETrue;

    }

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

// CXcapAddition::Result

//

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

//

TBool CXcapAddition::Result() const

    {

    return ETrue;

    }

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

// CXcapAddition::~CXcapAddition

//

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

//

CXcapAddition::~CXcapAddition()

    {

    #ifdef _DEBUG

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

    #endif

    }

//  End of File