/*

* Copyright (c) 2002-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: Header declaration

*

*/

#ifndef SEN_WEB_SERVICE_SESSION_H

#define SEN_WEB_SERVICE_SESSION_H

//  INCLUDES

#include "senservicesession.h"

#include "seninternalcredential.h"

// FORWARD DECLARATIONS

class MSenServiceConsumer;

class MServiceDescription;

class CSenCredential;

class CSenSoapMessage;

// CLASS DECLARATION

class CSenWebServiceSession : public CSenServiceSession,

                              public MSenCredentialObserver

    {

    public: // Destructor

        IMPORT_C virtual ~CSenWebServiceSession();

        // New functions

        IMPORT_C virtual TInt InitializeFromL(MSenServiceDescription& aServiceDescription);

        /**

        * Computes the status of this session (checks the credentials).

        * @return the status code, one of the following:

        * 

        */

        IMPORT_C virtual TInt ComputeStatusL();

        /*

        * Computes the status of this session and returns the status.

        * @return ETrue, if this session is expired and has invalid credentials

        *         EFalse, if this session is is ready and has valid credentials

        */

        IMPORT_C virtual TBool IsExpiredL(); // Remove, not called from anywhere

        IMPORT_C virtual TInt AddCredentialL(CSenCredential& aCredential);

        IMPORT_C virtual TInt ConstructSecurityTokenL(CSenCredential& aCredential,

                                                      HBufC8*& aToken);

        IMPORT_C virtual TInt NewMessageL(CSenSoapMessage*& aMessage);

        IMPORT_C virtual TInt MessageForSendingL(const TDesC8& aBody,

                                                 const TDesC8& aSenderID,

                                                 CSenSoapMessage*& aMessage);

        IMPORT_C virtual TInt ParseResponseL(const TDesC8& aResponse,

                                             HBufC8*& aParsed);

        IMPORT_C virtual CSenXmlReader* XmlReader();

        IMPORT_C virtual TInt ParseResponseL(const TDesC8& aResponse,

                                         CSenSoapMessage*& aMessage);

        IMPORT_C virtual TInt ParseMessageL(CSenSoapMessage& aSOAPMessage);

        /**

        * Adds a consumer. Takes ownership!

        * @return KErrNone if no errors, otherwise some system-wide errorcode

        */

        IMPORT_C virtual TInt AddConsumerL(MSenRemoteServiceConsumer& aConsumer);

        IMPORT_C virtual MSenRemoteServiceConsumer* Consumer();

        /**

        * Return an array in which the consumers (clients) of this ServiceSession

        * reside. This method is called from within several other methods of the

        * abstract ServiceSession class.

        * This method should be implemented by a subclass

        * specific to a ServiceInvocationFramework implementation.

        * @param    aConsumers  List of the current consumers. Owned by

        *           ServiceSession.

        * Ownership of the aConsumers is NOT transfered to the caller

        * @return TInt - a KErrNone or error

        */

        IMPORT_C virtual TInt Consumers(RServiceConsumerArray& aConsumers) const;

        IMPORT_C virtual TInt SubmitL(const TDesC8& aMessage,

                                      const TDesC8& aTransportProperties,

                                      MSenRemoteServiceConsumer& aConsumer,

                                      HBufC8*& aResponse);

        IMPORT_C virtual TInt SendL( const TDesC8& aMessage, 

                                     const TDesC8& aTransportProperties,

                                     MSenRemoteServiceConsumer& aConsumer,

                                     TInt& aTxnId,

                                     HBufC8*& aRevalidationError );

        IMPORT_C virtual TInt SubmitSoapL(const TDesC8& aSoapMessage, 

                                          const TDesC8& aTransportProperties,

                                          MSenRemoteServiceConsumer& aConsumer,

                                          HBufC8*& aResponse);

        IMPORT_C virtual TInt SendSoapL( const TDesC8& aSoapMessage, 

                                         const TDesC8& aTransportProperties,

                                         MSenRemoteServiceConsumer& aConsumer,

                                         TInt& aTxnId,

                                         HBufC8*& aRevalidationError );

        /**

        * Method checks if this session is ready to interact with (remote)

        * service. Typically, if service invocation framework requires 

        * credentials, they are checked inside this method.

        * @return boolean indicating if this session is ready (ETrue) or

        *         not (EFalse) to interact with (possibly remote) service.

        */

        IMPORT_C virtual TBool IsReadyL();

        // SOAP processing callback functions:

        IMPORT_C virtual TInt SendSoapMessageToConsumerL( CSenSoapMessage* apMessage,

                                                          const TInt aTxnId,

                                                          MSenRemoteServiceConsumer& aConsumer,

                                                          MSenProperties* aResponseTransportProperties );

        /**

        * This synchronous method (pair for SubmitL) checks if the service 

        * invocation framework (this session) can handle this fault, and 

        * if not, then an attempt is made to delivered this fault to session

        * consumer.

        *

        * @param aSoapMessage is the SOAP message representing fault.

        * @param aResponse is where either SOAP fault OR - if some

        * framework (like ID-WSF) was able to handle this fault (recover)

        *        - the valid response from the service, achieved

        *        by re-submitted request (for example to new endpoint,

        *        if the handled fault was "endpoint moved" -type fault.

        * @param aResponseTransportProperties will contain the properties of

        * handled error (either for fault OR valid response -transaction)

        *        

        * 

        * @return KErrSenSoapFault, if this error (fault) could not be handled.

        *         In this case, aResponse contains (extracted) SOAP fault

        *         element.

        *         KErrNone, if recovery was possible and successful, and

        *                   then aResponse contains valid response from 

        *                   the service. The SOAP fault, which was taken

        *                   care here - between (remote) service and

        *                   framework - remains thus "hidden" from actual 

        *                   web service consumer.

        *         KErrSenSoapFault, if fault could not be handled. Now

        *                   aResponse will contain the extracted SOAP

        *                   fault element as UTF-8 descriptor (TDesC8)

        *         KErrSenInternal, the SOAP fault could not be found from

        *                   aSoapMessage.

        *         KErrNotFound - the consumer could not be found.

        */

        IMPORT_C virtual TInt HandleSoapFaultL(CSenSoapMessage* apSoapMessage,

                                               HBufC8*& aResponse /*,

                                               CSenTransportProperties*& aResponseTransportProperties */);

        /**

        * This asynchronous method (pair for SendL) checks if the service 

        * invocation framework (this session) can handle this fault, and 

        * if not, then an attempt is made to delivered this fault to 

        * session consumer.

        *

        * @param aSoapMessage is the SOAP message representing fault.

        * @param aErrorCode, is the error code received from transport

        * @param aTxnId is the transaaction id from transport, which 

        *        can be used to map this error response to consumer's 

        *        request.

        * @param aConsumer is the consumer which was calling the transport

        *        and originally sent the request.

        * @param aResponseTransportProperties includes response properties

        * for the handled error

        * @return KErrNone, if error was either succesfully handled or

        *         processed (delivered to consumer) The SOAP fault, which 

        *         was taken care between (remote) service and ID-WSF framework

        *         is hereby "hidden" from actual web service consumer.

        */

        IMPORT_C virtual TInt HandleSoapFaultL(CSenSoapMessage* apSoapMessage,

                                           const TInt aErrorCode,

                                           const TInt aTxnID,

                                           MSenRemoteServiceConsumer& aConsumer,

                                           MSenProperties* aResponseTransportProperties);

        // From MSenServiceSession:

        IMPORT_C TInt SendToConsumerL(HBufC8* aMessage,

                                      const TInt aTxnId,

                                      MSenRemoteServiceConsumer& aConsumer,

                                      MSenProperties* aResponseTransportProperties = NULL); 

        IMPORT_C TInt SendErrorToConsumerL(const TInt aErrorCode,

                                           HBufC8* apError,

                                           const TInt aTxnId,

                                           MSenRemoteServiceConsumer& aConsumer,

                                           MSenProperties* aResponseTransportProperties = NULL); 

        IMPORT_C TInt HandleErrorL(const TInt aErrorCode,

                                   HBufC8* apError,

                                   const TInt aTxnId,

                                   MSenRemoteServiceConsumer& aConsumer,

                                   MSenProperties* aResponseTransportProperties = NULL); 

        IMPORT_C virtual TInt SendToHostletL(MSenRemoteHostlet& aReceiver,

                                             const TDesC8& aMessage,

                                             const TInt aTxnId,

                                             MSenRemoteServiceConsumer& aFrom,

                                             MSenProperties* aProperties);

        IMPORT_C virtual TInt ProvideHostletResponseL( MSenRemoteHostlet& aProvider,

                                                       const TInt aTxnId,

                                                       const TInt aServiceCode,

                                                       const TDesC8& aRecipientsConsumerId,

                                                       CSenChunk& aMessageChunk );

        IMPORT_C virtual void SetFrameworkHeadersL(CSenSoapMessage& aMsg);

        IMPORT_C virtual TInt SetUserNameL(TDesC8& aUsername);

        IMPORT_C virtual TPtrC8 Endpoint();

        IMPORT_C virtual TPtrC8 Contract();

        IMPORT_C virtual TPtrC8 FrameworkId();

        IMPORT_C virtual TPtrC8 FrameworkVersion();

        IMPORT_C virtual const TTime& ValidUntilL();

        IMPORT_C virtual void SetContractL(const TDesC8& aContract);

        IMPORT_C virtual void SetEndPointL(const TDesC8& aURI);

        IMPORT_C virtual void SetSecurityL(const TDesC8& aSecurity);

        IMPORT_C virtual void SetCredentialPtrL(RSenCredentialPtr aCredentialPtr);	//codescannerwarnings

        IMPORT_C virtual void FillCredentialIdentifierL(CSenCredentialIdentifier& aIdentifier);

        IMPORT_C virtual void StartTransaction();

        IMPORT_C virtual void TransactionCompleted();

        IMPORT_C virtual void WriteAsXMLToL(RWriteStream& aWriteStream);

        IMPORT_C virtual TTimeIntervalMicroSeconds ClientServerInterval();

        IMPORT_C virtual void SetClientServerIntervalL(TTimeIntervalMicroSeconds aInterval);	//codescannerwarnings

        IMPORT_C TBool HasConsumer() const;

        // From CSenWSDescription:

        IMPORT_C virtual TBool HasSuperClass( TDescriptionClassType aType );

        IMPORT_C virtual TInt SetTransportCueL(const TDesC8& aCue);

        IMPORT_C virtual TPtrC8 TransportCue();

        IMPORT_C TInt TryToSearchValidCredentialL();	//codescannerwarnings

        IMPORT_C virtual void CredentialChanged(TSenCredentialChange aChange, TAny* aPointer);

        // from MSenRemoteServiceSession

//        IMPORT_C TInt RemoveConsumerL(MSenRemoteServiceConsumer& aConsumer);

        IMPORT_C TInt GetCredentialIdL();

        IMPORT_C TInt AddCredentialObserverL(CSenInternalCredential& aCredential);

    protected:

        /**

        * C++ default constructor.

        */

        IMPORT_C CSenWebServiceSession( TDescriptionClassType aType,

                                        MSIF& aFramework);

        /**

        * By default Symbian 2nd phase constructor is private.

        */                              

        IMPORT_C void ConstructL();

        IMPORT_C HBufC8* SecurityL();

        IMPORT_C TBool HasSecurity();

        void SetCredentialIdL(TInt aCredentialId);	//codescannerwarnings

    private:

        TInt HandleBodyWithoutParsingL(CSenSoapMessage& aMessage, const TDesC8& aResponse);

    protected: // Data

        TTimeIntervalMicroSeconds iClientServerInterval;

         // Data, which also subclasses can access

        TTime iValidUntil;

        RSenCredentialPtr  iCredentialPtr;

        HBufC8* iTransportCue; 

    private: // Data

        HBufC8* iEndpoint;

        HBufC8* iContract;

        HBufC8* iFrameworkId;

        // credentials as xml

        HBufC8* iSecurity;

    };

#endif // SEN_WEB_SERVICE_SESSION_H

// End of File