/*
* 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:  Authorization out transaction handler.
*
*/

// INCLUDE FILES
#include "CPEngAuthorizationTransactionOut.h"

#include "CPEngAuthorizationResponse.h"
#include "MPEngAuthorizationEngine.h"

#include "MPEngXMLSerializer.h"
#include "MPEngXMLParser.h"

#include "MPEngPresenceAttrManager.h"
#include "PEngAttrLibFactory.h"

#include "CPEngTransactionStatus.h"
#include "PEngWVPresenceErrors2.h"
#include "PresenceDebugPrint.h"


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

// -----------------------------------------------------------------------------
// CPEngAuthorizationTransactionOut::CPEngAuthorizationTransactionOut()
// -----------------------------------------------------------------------------
//
CPEngAuthorizationTransactionOut::CPEngAuthorizationTransactionOut(
    MPEngAuthorizationEngine& aAuthEngine,
    MPEngPresenceAttrManager& aAttrManager,
    MPEngXMLParser& aXMLParser,
    TPEngWVCspVersion& aCSPVersion,
    TInt aOperationId )
        : iAuthEngine( aAuthEngine ),
        iAttributeManager( aAttrManager ),
        iXMLParser( aXMLParser ),
        iCSPVersion( aCSPVersion ),
        iTransCompleted( EFalse ),
        iOperationId( aOperationId )
    {
    PENG_DP( D_PENG_LIT( "CPEngAuthorizationTransactionOut::CPEngAuthorizationTransactionOut()" ) );
    iAuthEngine.LockForNetworkPublishing();
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationTransactionOut::ConstructL()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationTransactionOut::ConstructL()
    {
    iTransactionStatus =  CPEngTransactionStatus::NewL();
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationTransactionOut::NewLC()
// -----------------------------------------------------------------------------
//
CPEngAuthorizationTransactionOut* CPEngAuthorizationTransactionOut::NewLC(
    MPEngAuthorizationEngine& aAuthEngine,
    MPEngPresenceAttrManager& aAttrManager,
    MPEngXMLParser& aXMLParser,
    TPEngWVCspVersion& aCSPVersion,
    TInt aOperationId )
    {
    CPEngAuthorizationTransactionOut* self =
        new ( ELeave ) CPEngAuthorizationTransactionOut(
        aAuthEngine,
        aAttrManager,
        aXMLParser,
        aCSPVersion,
        aOperationId );
    CleanupStack::PushL( self );
    self->ConstructL( );

    return self;
    }


// Destructor
CPEngAuthorizationTransactionOut::~CPEngAuthorizationTransactionOut()
    {
    iAuthEngine.UnLockForNetworkPublishing();
    delete iResponse;
    delete iTransactionStatus;
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationTransactionOut::RequestL()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationTransactionOut::RequestL( TDes8& aSendBuffer )
    {
    aSendBuffer.Zero();
    MPEngXMLSerializer* xmlSerializer = CreateXmlSerializerL( aSendBuffer );
    CleanupClosePushL( *xmlSerializer );


    // <TransactionContent xmlns="http://www.wireless -village.org/TRC1.1">
    if ( iCSPVersion == EWVCspV11 )
        {
        xmlSerializer->StartTagL(  KTransactionContent );
        xmlSerializer->AttributeL( KXmlXmlns, KTransactionContentNS );
        }
    else
        {
        xmlSerializer->StartTagL( KTransactionContent );
        xmlSerializer->AttributeL( KXmlXmlns, KTransactionContentNS_CSP12 );
        }


    switch ( iResponse->AuthorizationStatus() )
        {
        case MPEngAuthorizationRequest::EPEngAuthAccepted: // fall through
        case MPEngAuthorizationRequest::EPEngAuthDenied:
            {
            AppendXMLPresenceAuthUserL( *xmlSerializer );
            break;
            }

        case MPEngAuthorizationRequest::EPEngAuthCanceled:
            {
            AppendXMLCancelAuthorizationL( *xmlSerializer );
            }

        default:
            {
            User::Leave( KErrNotSupported );
            break;
            }
        }


    // end of transaction
    // </TransactionContent>
    xmlSerializer->EndTagL( KTransactionContent );
    CleanupStack::PopAndDestroy( ); // xmlSerializer
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationTransactionOut::LastRunningTransactionHandler()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationTransactionOut::LastRunningTransactionHandler()
    {
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationTransactionOut::ProcessResponseL()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationTransactionOut::ProcessResponseL(
    const TDesC8& aResponse,
    TRequestStatus& /* aStatus */ )
    {
    PENG_DP( D_PENG_LIT( "CPEngAuthorizationTransactionOut::ProcessResponseL()" ) );


    // check if we have some answer from the server
    TInt err ( iXMLParser.ParseResultL( aResponse,
                                        iOperationId,
                                        *iTransactionStatus ) );
    // how did transaction go
    switch ( err )
        {
        case KErrNone: // transaction OK
            {
            // Authorization response went fine, store it
            iAuthEngine.UpdateAuthorizationStateL( *iResponse,
                                                   ( iCSPVersion == EWVCspV12 ) );
            break;
            }

        case KPEngNwErrUnrespondedPresenceRequest:
        case KPEngNwErrUnknownUser:
        case KPEngNwErrBadParameter:
            {
            // unknown user id,or bad param, remove Authorization request
            iAuthEngine.RemoveAuthorizationRequestL( *iResponse );
            break;
            }

        default:
            {
            }
        }

    iTransCompleted = ETrue;
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationTransactionOut::CancelProcessing()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationTransactionOut::CancelProcessing( )
    {
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationTransactionOut::NewTransactionHandlersL()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationTransactionOut::NewTransactionHandlersL(
    RPointerArray<MPEngOutgoingTransactionHandler>& /* aTransactionsArray*/ )
    {
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationTransactionOut::TransactionCompleted()
// -----------------------------------------------------------------------------
//
TBool CPEngAuthorizationTransactionOut::TransactionCompleted()
    {
    return iTransCompleted;
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationTransactionOut::TransactionResult()
// -----------------------------------------------------------------------------
//
CPEngTransactionStatus*  CPEngAuthorizationTransactionOut::TransactionResult()
    {
    CPEngTransactionStatus* temp = iTransactionStatus;
    iTransactionStatus = NULL;
    return temp;
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationTransactionOut::ReleaseHandler()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationTransactionOut::ReleaseHandler()
    {
    iTransCompleted = ETrue;
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationTransactionOut::SetAuthResponse()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationTransactionOut::SetAuthResponse(
    CPEngAuthorizationResponse* aResponse )
    {
    delete iResponse;
    iResponse = aResponse;
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationTransactionOut::AppendXMLPresenceAuthUserL()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationTransactionOut::AppendXMLPresenceAuthUserL(
    MPEngXMLSerializer& aXmlSerializer )
    {
    // <PresenceAuth-User>
    aXmlSerializer.StartTagL( KPresenceAuthUser );
    AppendXMLUserIdL( aXmlSerializer );

    // <Acceptance>
    aXmlSerializer.StartTagL( KAcceptance );


    if ( iResponse->AuthorizationStatus() == MPEngAuthorizationRequest::EPEngAuthAccepted )
        {
        aXmlSerializer.RawValueL( KXMLValueTrue );
        }
    else
        {
        aXmlSerializer.RawValueL( KXMLValueFalse );
        }
    // </Acceptance>
    aXmlSerializer.EndTagL( KAcceptance );


    // if CSP 1.2 we also append list of attributes to accept
    if ( iCSPVersion == EWVCspV12 )
        {
        const RArray<TUint32>& attributes = iResponse->AuthorizedAttributes();
        TInt count( attributes.Count() );
        // xmlns="Name space"
        // append attribute's namespace according to attributes on the list
        // Append Attribute name space
        TPtrC8 attributeName;
        TPtrC8 attributeNameSpace;
        User::LeaveIfError(
            iAttributeManager.GetAttributeXmlNameAndNameSpace( attributes[0],
                                                               attributeName,
                                                               attributeNameSpace ) );

        // <PresenceSubList>
        aXmlSerializer.StartTagL( KPresenceSubList );
        aXmlSerializer.AttributeL( KXmlXmlns, attributeNameSpace );

        // Append attributes one by one
        for ( TInt x( 0 ) ; x < count ; x++ )
            {
            User::LeaveIfError(
                iAttributeManager.GetAttributeXmlNameAndNameSpace( attributes[ x ],
                                                                   attributeName,
                                                                   attributeNameSpace ) );

            aXmlSerializer.StartTagL( attributeName
                                    ).EndTagL( attributeName );
            }

        // </PresenceSubList>
        aXmlSerializer.EndTagL( KPresenceSubList );
        }

    // </PresenceAuth-User>
    aXmlSerializer.EndTagL( KPresenceAuthUser );
    }


// -----------------------------------------------------------------------------
// CPEngAuthorizationTransactionOut::AppendXMLCancelAuthorizationL()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationTransactionOut::AppendXMLCancelAuthorizationL(
    MPEngXMLSerializer& aXmlSerializer )
    {
    //  <CancelAuth-Request>
    aXmlSerializer.StartTagL( KCancelAuthRequest );

    AppendXMLUserIdL( aXmlSerializer );

    // </CancelAuth-Request>
    aXmlSerializer.EndTagL( KCancelAuthRequest );
    }

// -----------------------------------------------------------------------------
// CPEngAuthorizationTransactionOut::AppendXMLUserIdL()
// -----------------------------------------------------------------------------
//
void CPEngAuthorizationTransactionOut::AppendXMLUserIdL(
    MPEngXMLSerializer& aXmlSerializer )
    {
    aXmlSerializer.StartTagL( KUserIDXMLTag
                            ).WvAddressL( iResponse->Id()
                                        ).EndTagL( KUserIDXMLTag );
    }

//  End of File