/*

* Copyright (c) 2006-2006 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:           

*

*/

// INCLUDE FILES

#include <SenXmlUtils.h>

#include "wsstarsessionconsumer.h"

#include "sendebug.h"

#include <SenServiceConnection.h>

#include "senlogger.h"

#include "wsstarcons.h"

CWSStarSessionConsumer* CWSStarSessionConsumer::NewL( MSenRemoteServiceConsumer& aServiceConsumer,

                                                      RFileLogger& aLogger )

    {

    CWSStarSessionConsumer* pSelf =

        CWSStarSessionConsumer::NewLC(aServiceConsumer, aLogger);

    CleanupStack::Pop(pSelf);

    return pSelf;

    }

CWSStarSessionConsumer* CWSStarSessionConsumer::NewLC( MSenRemoteServiceConsumer& aServiceConsumer,

                                                       RFileLogger& aLogger )

    {

    CWSStarSessionConsumer* pSelf =

                        new (ELeave) CWSStarSessionConsumer( aServiceConsumer, aLogger );

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL();

    return pSelf;

    }

CWSStarSessionConsumer::~CWSStarSessionConsumer()

    {

    //delete iSentMessageId;

    //delete iReceivedMessageId;

    iSentMessages.Reset();

    iSendReplyTo.Reset();

    iTranspProp.Reset();

    }

CWSStarSessionConsumer::CWSStarSessionConsumer( MSenRemoteServiceConsumer& aServiceConsumer,

                                                RFileLogger& aLogger )

:   iConsumer(aServiceConsumer),

    iLogger(aLogger),

    //iSentMessageId(NULL),

    //iReceivedMessageId(NULL),

    iSentMessages(ETrue, ETrue),

    iSendReplyTo(ETrue, ETrue),

    iTranspProp(ETrue, ETrue)

    {

    }

const TDesC8& CWSStarSessionConsumer::Id() const

    {

    return iConsumer.Id();

    }

TInt CWSStarSessionConsumer::SetSessionL(MSenRemoteServiceSession& aServiceSession)

    {

    iConsumer.SetSessionL(aServiceSession);

    return KErrNone;

    }

void CWSStarSessionConsumer::HandleSoapMessageL( CSenSoapMessage* apMessage,

                                                 const TInt aTxnId,

                                                 MSenProperties* aResponseTransportProperties,

                                                 TBool aCompleteMessage )

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarSessionConsumer::HandleSoapMessageL(CSenSoapMessage*)");

    if ( apMessage )

        {

        CleanupStack::PushL( apMessage ); // this method has the ownership, until passed forward(!)

        // fix for the error HTUR-6XDABN : Start

    	// After sending the message to Remote consumer, Corresponding message is not 

    	// removed from the message queue. Due to this the message body sits in the 

    	// queue (memory) till the session consumer object gets destroyed. 

    	CSenElement& header = apMessage->HeaderL();

    	// Response RelatesTo content=MessageId of the request

        RPointerArray<CSenElement>& msgIdArray = header.ElementsL();

    	for(TInt i = 0; i < msgIdArray.Count(); i++)

    		{

    		CSenElement& idElement = *msgIdArray[i];

    		if( idElement.LocalName() == WSStarContextKeys::KRelatesTo() )

    			{

            	// Remove the consumed message from the message queue 

            	iSentMessages.RemoveByKey( idElement.Content() );

            	iTranspProp.RemoveByKey( idElement.Content() ); 		

            	break;

    			}

    		}

    	// msgIdArray.Close(); // Must be removed (now commented out) OR otherwise regression 

    	                       // (MMAA-6YFQ5V) will occur! The msgIdArray is a *reference*, 

    	                       // and any modification to this array will MODIFY the actual

    	                       // contents of that DOM tree(!). 

    	// fix for the error HTUR-6XDABN : End

        HBufC8* pMessageAsString = NULL;

        if (aCompleteMessage)

            {

            TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- Returning whole SOAP-ENV");

            pMessageAsString = apMessage->AsXmlL();

            }

        else

            {

            TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- Detaching SOAP body (calling BodyAsStringL).");

            pMessageAsString = apMessage->BodyAsStringL();

            }

        CleanupStack::PopAndDestroy( apMessage ); // object has been serialized into a descriptor => de-alloc it

        if (pMessageAsString)

            {

            iConsumer.HandleMessageL(pMessageAsString, aTxnId, aResponseTransportProperties);

            }

        else

            {

            TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- Fatal(!): pMessageAsString == NULL, invoking remote consumer's HandleErrorL.");

            iConsumer.HandleErrorL(NULL, KErrSenNoSoapBody, aTxnId, aResponseTransportProperties);

            }

        }

    else // apMessage == NULL

        {

        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel,"- Fatal(!): WSStarSessionConsumer::HandleSoapMessageL, apMessage == NULL, sending KErrSenInternal to remote consumer via HandleErrorL.");

        iConsumer.HandleErrorL(NULL, KErrSenInternal, aTxnId, aResponseTransportProperties);

        }           

    }

TInt CWSStarSessionConsumer::HandleMessageL( HBufC8* apMessage,

                                             const TInt aTxnId,

                                             MSenProperties* aResponseTransportProperties )

    {

#ifdef _SENDEBUG

    CleanupStack::PushL(apMessage);

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarSessionConsumer::HandleMessageL");

    CleanupStack::Pop(apMessage);

#endif // _SENDEBUG    

    return iConsumer.HandleMessageL(apMessage, aTxnId, aResponseTransportProperties);

    }

TInt CWSStarSessionConsumer::HandleErrorL( HBufC8* apError,

                                           const TInt aErrorCode,

                                           const TInt aTxnId,

                                           MSenProperties* aResponseTransportProperties )

    {

#ifdef _SENDEBUG

    CleanupStack::PushL(apError);

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarSessionConsumer::HandleErrorL");

    CleanupStack::Pop(apError);

#endif // _SENDEBUG    

    return iConsumer.HandleErrorL(apError, aErrorCode, aTxnId, aResponseTransportProperties);

    }

void CWSStarSessionConsumer::SetStatusL(const TInt status)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarSessionConsumer::SetStatusL");

    //we will not inform consumers about  fact that credential is expired, 

    // ws* has to obtain new ticket and keep connection valid

    if (status == KSenConnectionStatusExpired) 

        {

        iConsumer.SetStatusL(KSenConnectionStatusReady);    

        }

    else

        {

        iConsumer.SetStatusL(status);

        }

    }

TInt CWSStarSessionConsumer::MessageForSendingL(const TDesC8& aBody,

                                           CWSStarMessageContext*& aCtx)

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CWSStarSessionConsumer::MessageForSendingL");

    //do nothing with message. Message is preapred by session and handlers

    //we need only set correlation id using context which travel with message

    //------------SCHarF ------- glue with addressing to get messageId. We will expect some answer

    const TDesC8* msgId = aCtx->GetDesC8L(WSStarContextKeys::KMessageID);

    const TDesC8* replyTo = aCtx->GetDesC8L(WSStarContextKeys::KReplyTo);

    if (msgId)

        {

        iSentMessages.Append(msgId->AllocL(), aBody.AllocL());    

        if(replyTo)

            {

            iSendReplyTo.Append(msgId->AllocL(), replyTo->AllocL());

            }

        const TDesC8* transpProp =

                aCtx->GetDesC8L(WSStarContextKeys::KWSStarTranspProp);

        if (transpProp)

            {

            iTranspProp.Append(msgId->AllocL(), transpProp->AllocL());

            }

        }

    //------------end SCHarF ------- 

    return KErrNone;

    }

void CWSStarSessionConsumer::ConstructL()

    {

    }

/*void CWSStarSessionConsumer::SetSentMessageIdL(const TDesC8& aSentMessageId)

    {

    HBufC8* pNew = NULL;

    if(aSentMessageId.Length()>0)

        pNew = aSentMessageId.AllocL();

    delete iSentMessageId;

    iSentMessageId = pNew;

    }

TPtrC8 CWSStarSessionConsumer::SentMessageId()

    {

    if(iSentMessageId)

        {

        return *iSentMessageId;

        }

    else

        {

        return KNullDesC8();

        }

    }

void CWSStarSessionConsumer::SetReceivedMessageIdL(

                                            const TDesC8& aReceivedMessageId)

    {

    HBufC8* pNew =NULL;

    if(aReceivedMessageId.Length()>0)

        pNew = aReceivedMessageId.AllocL();

    delete iReceivedMessageId;

    iReceivedMessageId = pNew;

    }

TPtrC8 CWSStarSessionConsumer::ReceivedMessageId()

    {

    if(iReceivedMessageId)

        return *iReceivedMessageId;

    else

        return KNullDesC8();

    }

*/

TBool CWSStarSessionConsumer::Expects(const TDesC8& aRelatesTo, const TDesC8* aTo)

    {

    TInt index = iSentMessages.Find(aRelatesTo);

    TBool result(EFalse);

    TInt index2 = index; 

    if (aTo)

        index2 = iSendReplyTo.Find(aRelatesTo);

    if (index == index2 && index2 != KErrNotFound)

        {

        if (aTo)

            {

            const TDesC8* replyTo = iSendReplyTo.ValueAt(index);

            if (*replyTo == *aTo)

                {

                result = ETrue;

                }

            else

                {

                TLSLOG(KSenFaultsLogChannel, KSenFaultsLogLevel, WSStarSessionConsumer::KFaultInvalidToTag);   

                }

            }

        else

            {

            result = ETrue;

            }

        }

    else

        {

        TLSLOG(KSenFaultsLogChannel, KSenFaultsLogLevel, WSStarSessionConsumer::KFaultInvalidRelatesToTag);   

        }

    return result;

    }

TDesC8* CWSStarSessionConsumer::BodyL(const TDesC8& aMessageID) const

    {

    HBufC8* pBody = NULL;

    TInt index = iSentMessages.Find(aMessageID);

    if (index != KErrNotFound)

        {

        pBody = (HBufC8*)iSentMessages.ValueAt(index);

        }

    return pBody;

    }

const TDesC8& CWSStarSessionConsumer::TransportProperties(

        const TDesC8& aMessageID) const

    {

    TInt index = iTranspProp.Find(aMessageID);

    if (index != KErrNotFound)

        {

        const TDesC8* tp = iTranspProp.ValueAt(index);

        if (tp)

            {

            return *tp;

            }

        }

    return KNullDesC8;

    }

MSenTransport& CWSStarSessionConsumer::TransportL()

    {

    return iConsumer.TransportL();

    }

TInt CWSStarSessionConsumer::ChunkByTxnIdL(TInt aTxnId, CSenChunk*& aChunk)

    {

    return iConsumer.ChunkByTxnIdL(aTxnId, aChunk);

    }

void CWSStarSessionConsumer::FileProgress(TInt /*aTxnId*/, TBool /*aIncoming*/, TBool /*aIsSoap*/,

                const TDesC8& /*aSoapOrCid*/, TInt /*aProgress*/)

    {

    }

CSenIdentifier& CWSStarSessionConsumer::Identifier() const

    {

    return iConsumer.Identifier();

    }

// enable file logging (macros)

RFileLogger* CWSStarSessionConsumer::Log() const

    {

    return (RFileLogger*) &iLogger;

    }

TBool CWSStarSessionConsumer::HasAuthenticationCallback()

    {

    return iConsumer.HasAuthenticationCallback();

    }

TInt CWSStarSessionConsumer::ReauthenticationNeededL(CSenIdentityProvider*& aIdp)

	{

	return iConsumer.ReauthenticationNeededL(aIdp);

	}

void CWSStarSessionConsumer::SetDataTrafficDetails( TSenDataTrafficDetails&  aDetails)  

	{

	iConsumer.SetDataTrafficDetails(aDetails);

	}

TBool CWSStarSessionConsumer::HasCoBrandingCallback()

    {

    return iConsumer.HasCoBrandingCallback();

    }

TBool CWSStarSessionConsumer::OnGetBrandIdL(  const TDesC8& aBrandIdListAsXmlSnippet, RBuf8& aSelectedBrandId)

    {

    return iConsumer.OnGetBrandIdL(aBrandIdListAsXmlSnippet,aSelectedBrandId);

    }

// End of file