/*

* 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 in transaction handler.

*

*/

// INCLUDE FILES

#include "CPEngAuthorizationTransactionIn.h"

#include "CPEngAuthorizationRequest.h"

#include "CPEngAuthorizationResponse.h"

#include "MPEngAuthorizationEngine.h"

#include "MPEngXMLParser.h"

#include "MPEngPresenceAttrManager.h"

#include "PEngWVPresenceErrors2.h"

#include "PresenceDebugPrint.h"

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

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

// CPEngAuthorizationTransactionIn::CPEngAuthorizationTransactionIn()

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

//

CPEngAuthorizationTransactionIn::CPEngAuthorizationTransactionIn(

    MPEngAuthorizationEngine& aAuthEngine,

    MPEngPresenceAttrManager& aAttrManager,

    MPEngXMLParser& aXMLParser,

    const TDesC8& aParseBlock,

    TPEngAuthorizationTransType aType )

        : iAuthEngine( aAuthEngine ),

        iAttributeManager( aAttrManager ),

        iXMLParser( aXMLParser ),

        iParseBlock( aParseBlock ),

        iResponseType( aType )

    {

    PENG_DP( D_PENG_LIT( "CPEngAuthorizationTransactionIn::CPEngAuthorizationTransactionIn" ) );

    }

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

// CPEngAuthorizationTransactionIn::ConstructL()

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

//

void CPEngAuthorizationTransactionIn::ConstructL()

    {

    }

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

// CPEngAuthorizationTransactionIn::NewL()

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

//

CPEngAuthorizationTransactionIn* CPEngAuthorizationTransactionIn::NewL(

    MPEngAuthorizationEngine& aAuthEngine,

    MPEngPresenceAttrManager& aAttrManager,

    MPEngXMLParser& aXMLParser,

    const TDesC8& aParseBlock,

    TPEngAuthorizationTransType aType )

    {

    CPEngAuthorizationTransactionIn* self = NewLC( aAuthEngine,

                                                   aAttrManager,

                                                   aXMLParser,

                                                   aParseBlock,

                                                   aType );

    CleanupStack::Pop();

    return self;

    }

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

// CPEngAuthorizationTransactionIn::NewLC()

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

//

CPEngAuthorizationTransactionIn* CPEngAuthorizationTransactionIn::NewLC(

    MPEngAuthorizationEngine& aAuthEngine,

    MPEngPresenceAttrManager& aAttrManager,

    MPEngXMLParser& aXMLParser,

    const TDesC8& aParseBlock,

    TPEngAuthorizationTransType aType )

    {

    CPEngAuthorizationTransactionIn* self =

        new ( ELeave ) CPEngAuthorizationTransactionIn(

        aAuthEngine,

        aAttrManager,

        aXMLParser,

        aParseBlock,

        aType );

    CleanupStack::PushL( self );

    self->ConstructL( );

    return self;

    }

// Destructor

CPEngAuthorizationTransactionIn::~CPEngAuthorizationTransactionIn()

    {

    }

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

// CPEngAuthorizationTransactionIn::ProcessRequestL()

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

//

void CPEngAuthorizationTransactionIn::ProcessRequestL(

    const TDesC8& /*aRequest*/,

    TRequestStatus& /*aStatus*/ )

    {

    HBufC* userId = ParseUserIdLC();

    switch ( iResponseType )

        {

        case EPEngAuthorizationRequest:

            {

            PENG_DP( D_PENG_LIT( "CPEngAuthorizationTransactionIn::ProcessRequestL() - AuthRequest[%S]" ),

                     userId );

            CPEngAuthorizationRequest* authRequest =

                CPEngAuthorizationRequest::NewLC( *userId,

                                                  iAuthEngine.SizeCounter() );

            ParseAttrListL( *authRequest,

                            &CPEngAuthorizationRequest::AddRequestedAttributeL );

            // store authorization request

            // removes authRequest from cleanupstack

            iAuthEngine.AddAuthRequestLX( authRequest );

            break;

            }

        case EPEngAuthorizationResponse:

            {

            PENG_DP( D_PENG_LIT( "CPEngAuthorizationTransactionIn::ProcessRequestL() - AuthResponse[%S]" ),

                     userId );

            CPEngAuthorizationResponse* authStatus =

                CPEngAuthorizationResponse::NewLC( *userId,

                                                   iAuthEngine.SizeCounter() );

            ParseAttrListL( *authStatus,

                            &CPEngAuthorizationResponse::AddAttributeL );

            ParseAuthorizationStatusL( *authStatus );

            // store authorization status

            // removes authStatus from cleanupstack

            iAuthEngine.AddAuthStatusLX(  authStatus );

            break;

            }

        default:

            {

            break;

            }

        }

    CleanupStack::PopAndDestroy( userId );

    }

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

// CPEngAuthorizationTransactionIn::CancelProcessing()

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

//

void CPEngAuthorizationTransactionIn::CancelProcessing()

    {

    }

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

// CPEngAuthorizationTransactionIn::ParseUserIdL()

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

//

HBufC* CPEngAuthorizationTransactionIn::ParseUserIdLC()

    {

    if ( !iXMLParser.DecodeL( iParseBlock, KUserIDXMLTag, EFalse ) )

        {

        // message is corrupted, ignore it

        User::Leave( KErrArgument );

        return NULL;

        }

    HBufC* userId = iXMLParser.ResultAsWVAddressL();

    CleanupStack::PushL( userId );

    return userId;

    }

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

// CPEngAuthorizationTransactionIn::ParseAttrListL()

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

//

template <class AuthItem>

void CPEngAuthorizationTransactionIn::ParseAttrListL(

    AuthItem& aAuthItem,

    void ( AuthItem::* aAddFunc )( TUint32 ) )

    {

    // read list of attributes

    if ( iXMLParser.DecodeL( iParseBlock, KPresenceSubList, ETrue ) )

        {

        // store list of attributes

        TPtrC8 attributesBlock = iXMLParser.ResultL();

        //look for all supported attributes

        TArray<TUint32> supportedAt = iAttributeManager.KnownAttributeTypes();

        TInt count( supportedAt.Count() );

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

            {

            // get attribute's name

            TPtrC8 nameSpace;

            TPtrC8 attrName;

            if ( ( KErrNone == iAttributeManager.GetAttributeXmlNameAndNameSpace(

                       supportedAt[ x ],

                       attrName,

                       nameSpace ) )

                 &&

                 ( iXMLParser.DecodeL( attributesBlock, attrName, EFalse ) ) )

                {

                ( aAuthItem.*aAddFunc )( supportedAt[ x ] );

                }

            }

        }

    }

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

// CPEngAuthorizationTransactionIn::ParseAuthorizationStatusL()

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

//

void CPEngAuthorizationTransactionIn::ParseAuthorizationStatusL(

    CPEngAuthorizationResponse& aAuthStatus )

    {

    TBool acceptance( EFalse );

    if ( iXMLParser.DecodeL( iParseBlock,

                             KAcceptance,

                             EFalse ) )

        {

        acceptance = ( iXMLParser.ResultL().CompareF( KXMLValueTrue ) == KErrNone );

        }

    if ( acceptance )

        {

        aAuthStatus.SetResponseType( MPEngAuthorizationStatus::EPEngAuthAccepted );

        }

    else

        {

        aAuthStatus.SetResponseType( MPEngAuthorizationStatus::EPEngAuthDenied );

        }

    }

//  End of File