// Copyright (c) 2002-2009 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$

// This module implements the collection of HTTP Transaction test classes

// by:		mjdavey, symbian@mjdss.com, August 2002

// for:	Typhoon (7.0s) & JetStream (8.0)

// Include Files  

// 

//

#include <e32base.h>

#include "CHTTPFamily.h"

#include "HttpFrmwrk.h"

#include "HttpTransactionCmds.h"

#include "httptransaction.h"

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

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

//	Command:	TRANSACTION command.

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

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

//

//	Form(s):

//				TRANSACTION <connection name> <method> 

//				TRANSACTION <connection name> <method> <URI>

//	Example:	

//				a)	TRANSACTION framework1 get $URI$

//				b)	TRANSACTION framework2 get "http://news.bbc.co.uk/nol/shared/img/global_toolbar/logo.gif"

//				c)	TRANSACTION framework2 post 

//

//	this assumes that <connection name> has already been defined (see CONNECT)

//	examp a) assumes that define URI has already been created (see DEFINE) 

//	examp b) is full form

//	examp c) is for post and will be detailed later

CCmdTransaction *CCmdTransaction::NewL(TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase)

	{

	CCmdTransaction *self = NewLC( aCommandId, aKeyphrase, aHelpPhrase);

	CleanupStack::Pop();

	return self; 

	}

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

CCmdTransaction *CCmdTransaction::NewLC(TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase)

	{

	CCmdTransaction *self = new (ELeave) CCmdTransaction();

	CleanupStack::PushL( self );

	self->ConstructL(aCommandId, aKeyphrase, aHelpPhrase);

	return self;

	}

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

void CCmdTransaction::ConstructL(TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase)

	{

	CCmdBase::ConstructL(aCommandId, aKeyphrase, aHelpPhrase);

	//	set local vars for convenience

	iTransactionIndex = -1;

	iExpectedError = 0;

	iExpectError = EFalse;

	iTestFail = 0;

	iExpectedStatusCode = 200;

	eStrIndex = HTTP::ECONNECT;

	iHasARequestBody = EFalse;

	iExpectedNumberRedirects = 0;

	}

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

CCmdTransaction::~CCmdTransaction(void) {}

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

//	This must have three parameters: <connection tagname> <methodname> and <uri>

//	the tagname must be checked against existing valid tags and the methodname

//	against a list of our creation. the URI may be an existing define or 

//	a string

TInt CCmdTransaction::ProcessL(const TDesC& aCommand)

	{

	// Complete the test machine - will then get the next cmd

	Machine()->CompleteRequest();

	TPtrC transname;

	TPtrC conname;

	TPtrC transmthd;

	TPtrC transURI;

	TPtrC postData;

	TInt error;

	// ParseCmdArgs indirectly sets eStrIndex

	if (( error = ParseCmdArgs( aCommand, 

							    transname, 

								conname, 

								transmthd, 

								transURI, 

								postData)) != KErrNone)

		return error;

	if (conname.Size() == 0)

		{

		(void) ShowTransactions () ;

		return error;

		}

	//	Get the session object we need

	//	If it is return error, if not create a session and ptr!

	CAnyObject *cnx = (CAnyObject *)Machine()->Domains()->Name(conname);

	if (cnx == NULL)//	does not already exists

		return Error(KErrArgument, THA_KErrInvalidConnect, &conname);

	else

		{

		//	reset the received status 

		iReceivedError = -1;

		CFrmwrkSession *myConnection = (CFrmwrkSession *) cnx->Ptr();

		// TPtrC myName = myConnection->Name() ;

		RHTTPSession mySession = myConnection->Session();

		CTestTransaction *transaction = NULL;

		TRAPD(err, transaction = CTestTransaction::NewL( mySession,

														 eStrIndex, 

		                                                 transURI, 

		                                                 postData, 

		                                                 transname,

		                                                 Machine()));

		if (err != KErrNone) 

			{

			Log(_L("Failed to create Transaction %S"), &transname);

			return err;

			}

		else

			{

			Log(_L("Transaction %S created successfully"), &transname);

			}

		TRAP ( err, transaction->SubmitL());

		if (err != KErrNone) 

			{

			Log(_L("Transaction %S,  Submission failed"), &transname);

			return err;

			}

		else

			{

			Log(_L("Transaction %S,  Submission succeeded"), &transname);

			}

		Machine()->Domains()->AddL(transname, eStrIndex, THA_KHTTP_Transaction, (TAny *) transaction);

		}

	if (error != KErrNone)

		Log(TFR_KFmtErrFailed, &Keyphrase(), error);

	return error;

}

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

TInt CCmdTransaction::ParseCmdArgs( const TDesC& aCommand, 

								    TPtrC& aTransName,

								    TPtrC& aConName, 

									TPtrC& aTransMthd, 

									TPtrC& aTransURI,

									TPtrC& aPostData)

	{

	aConName.Set(NULL, 0);

	aTransName.Set(NULL, 0);

	aTransMthd.Set(NULL, 0);

	aTransURI.Set(NULL, 0);

	aPostData.Set(NULL, 0);

	//	get the command into a local string

	TPtrC param;

	TInt error = KErrNone;

	TRAP(error, param.Set( ParamsL(aCommand)));

	if (error != KErrNone)

		return Error(error, TFR_KFmtErrBadCmd, &Keyphrase());

	//	check its' valid

	TLex parse(param);

	if (!parse.Eos() && !parse.Peek().IsSpace())

		return Error(error, TFR_KFmtErrBadCmd, &parse);

	//	remove any spaces and see if its got params

	parse.SkipSpace();

	if (parse.Eos())	// If no params, print out present connections.

		return error;

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

	//	Get transaction name, must not exceed 16 characters.

	TRAP(error, aTransName.Set(TfrLex::GetL(parse)));

	if ( error != KErrNone) 

		return Error(KErrArgument, TFR_KFmtErrBadCmd, &aTransName);

	//	check transaction name is valid length

	aTransName.Set(TfrLex::Peel(aTransName));

	if (aTransName.Length() > 16) 

		return Error(KErrArgument, THA_KErrParameterLong, &aTransName);

	if (aTransName.Length() <= 0)

		return Error(KErrArgument, TFR_KFmtErrMissingParams, &Keyphrase());

	CAnyObject *cnx = (CAnyObject *)Machine()->Domains()->Name(aTransName);

	if (cnx != NULL)		//	already exists

		return Error(KErrAlreadyExists, THA_KErrCnxionExists, &aTransName);

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

	//	Get framework name, must not exceed 16 characters.

	//	should be http or wsp (currently)

	TRAP(error, aConName.Set(TfrLex::GetL(parse)));

	if ( error != KErrNone) 

		return Error(KErrArgument, TFR_KFmtErrBadCmd, &aConName);

	//	check connection name is valid length

	aConName.Set(TfrLex::Peel(aConName));

	if (aConName.Length() > 16) 

		return Error(KErrArgument, THA_KErrParameterLong, &aConName);

	if (aConName.Length() <= 0)

		return Error(KErrArgument, TFR_KFmtErrMissingParams, &Keyphrase());

	//	check connection name exists

	if (!checkConnectionExists(aConName))

		return Error(KErrArgument, THA_KErrConnectionNotExists, &aConName);

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

	// Get method value.

	TRAP(error, aTransMthd.Set(TfrLex::GetL(parse)));

	if (error != KErrNone) 

		return Error(KErrArgument, TFR_KFmtErrBadCmd, &aTransMthd);

	//	check method name is valid length

	aTransMthd.Set(TfrLex::Peel(aTransMthd));

	if (aTransMthd.Length() > 16) 

		return Error(KErrArgument, THA_KErrParameterLong, &aTransMthd);

	if (aTransMthd.Length() <= 0)

		return Error(KErrArgument, TFR_KFmtErrMissingParams, &Keyphrase());

	//	check method defined

	if (!checkMethodExists(aTransMthd))

		return Error(KErrArgument, THA_KErrMethodNotExists, &aTransMthd);

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

	// Get URI value.

	TRAP(error, aTransURI.Set(TfrLex::GetL(parse)));

	if (error != KErrNone) 

		return Error(KErrArgument, TFR_KFmtErrBadCmd, &aTransURI);

	//	uri's may be enormous so lets not bother worrying about length!

	aTransURI.Set(TfrLex::Peel(aTransURI));

	if (aTransURI.Length() <= 0)

		return Error(KErrArgument, TFR_KFmtErrMissingParams, &Keyphrase());

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

	//	Get Additional Parameters

	//	some commands (e.g. POST) may require an additional parameter

	//	to provide either filename (for source data) or block of text

	//	for posting...

	TRAP(error, aPostData.Set(TfrLex::GetL(parse)));

	if (error != KErrNone) 

		return Error(KErrArgument, TFR_KFmtErrBadCmd, &aPostData);

	//	datablocks and filenames may be enormous so lets not bother worrying about length!

	aPostData.Set(TfrLex::Peel(aPostData));

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

	//	There should not be anything more (currently)

	//  Future additions MAY required optional parameters and therefore the following may

	//	need to be dumped...

	TPtrC remainder = TfrLex::Trim(parse.Remainder());

	if (remainder.Length() > 0) 

		return Error(KErrArgument, TFR_KFmtErrBadCmd, &remainder);

	aConName.Set(TfrLex::Peel(aConName));

	return (KErrNone);

	}

void CCmdTransaction::ShowTransactions() 

	{

	TInt iTrans = 0;

	CObjCatalogue *trnsctns = Machine()->Domains();

	Log(_L("\tCurrent Transactions:"));

	Log(_L("\tName  \tMethod  \tURI"));

	for (TInt i = 0; i < trnsctns->Count(); ++i)

		{

		CAnyObject *obj = (CAnyObject *)trnsctns->At(i);

		if (obj->Tag() == THA_KHTTP_Transaction)

			{

			TPtrC label = obj->Name();

			TInt eStrIndex = obj->Index();

			CTestTransaction *trans = (CTestTransaction *)obj->Ptr();

			TBuf<256> uri;

			uri.Copy (trans->Uri()) ;

			TPtrC mthd;

			switch (eStrIndex)

				{

				case HTTP::EGET : mthd.Set(THA_TxtCmdTransactionGET); break;

				case HTTP::EPOST : mthd.Set(THA_TxtCmdTransactionPOST); break;

				case HTTP::EPUT : mthd.Set(THA_TxtCmdTransactionPUT); break;

				case HTTP::EDELETE : mthd.Set(THA_TxtCmdTransactionDELETE); break;

				case HTTP::EHEAD : mthd.Set(THA_TxtCmdTransactionHEAD); break;

				case HTTP::EOPTIONS : mthd.Set(THA_TxtCmdTransactionOPTIONS); break;

				case HTTP::ETRACE : mthd.Set(THA_TxtCmdTransactionTRACE); break;

				default : break;

				}

			++iTrans;

			Log(_L("\t%d\t%S\t%S\t%S"), iTrans, 

				&label, 

				&mthd,

				&uri);

			}

		}

	if (iTrans == 0)

		Log(_L("\tNo transactions have been defined"));

	}

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

//	check connection name exists

//	we have to connect to the object catalogue and look at sessions!

TBool CCmdTransaction::checkConnectionExists(TPtrC &aName)

	{

	CObjCatalogue *sessions = Machine()->Domains();

	for (TInt i = 0; i < sessions->Count(); ++i)

		{

		CAnyObject *obj = (CAnyObject *)sessions->At(i);

		if (obj->Tag() == THA_KHTTP_Connect)

			{

			TPtrC sessname = obj->Name();

			if (sessname.CompareF(aName) == 0)

				return ETrue;

			}

		}

	return EFalse;

	}

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

//	check method name exists

//	we have to compare supplied name to our existing list of method

//	use crude compare for now, but perhaps add more elegant list facility?!

//	the enums are from HttpStringConstants.h and should not be interferred with!!!

TBool CCmdTransaction::checkMethodExists(TPtrC &aName)

	{

	if (aName.CompareF(THA_TxtCmdTransactionGET) == 0) 

		{

		eStrIndex = HTTP::EGET;

		return ETrue;

		}

	else if (aName.CompareF(THA_TxtCmdTransactionPOST) == 0) 

		{

		eStrIndex = HTTP::EPOST;

		return ETrue;

		}

	else if (aName.CompareF(THA_TxtCmdTransactionPUT) == 0) 

		{

		eStrIndex = HTTP::EPUT;

		return ETrue;

		}

	else if (aName.CompareF(THA_TxtCmdTransactionHEAD) == 0) 

		{

		eStrIndex = HTTP::EHEAD;

		return ETrue;

		}

	else if (aName.CompareF(THA_TxtCmdTransactionDELETE) == 0) 

		{

		eStrIndex = HTTP::EDELETE;

		return ETrue;

		}

	else if (aName.CompareF(THA_TxtCmdTransactionOPTIONS) == 0) 

		{

		eStrIndex = HTTP::EOPTIONS;

		return ETrue;

		}

	else if (aName.CompareF(THA_TxtCmdTransactionTRACE) == 0) 

		{

		eStrIndex = HTTP::ETRACE;

		return ETrue;

		}

	return EFalse;

	}

CCmdEndTransaction *CCmdEndTransaction::NewL(TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase)

	{

	CCmdEndTransaction *self = NewLC( aCommandId, aKeyphrase, aHelpPhrase);

	CleanupStack::Pop();

	return self; 

	}

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

CCmdEndTransaction *CCmdEndTransaction::NewLC(TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase)

	{

	CCmdEndTransaction *self = new (ELeave) CCmdEndTransaction();

	CleanupStack::PushL( self );

	self->ConstructL(aCommandId, aKeyphrase, aHelpPhrase);

	return self;

	}

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

void CCmdEndTransaction::ConstructL(TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase)

	{

	CCmdBase::ConstructL(aCommandId, aKeyphrase, aHelpPhrase);

	}

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

CCmdEndTransaction::~CCmdEndTransaction(void) {}

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

TInt CCmdEndTransaction::ParseCmdArgs( const TDesC& aCommand, 

								    TPtrC& aTransName)

	{

	aTransName.Set(NULL, 0);

	//	get the command into a local string

	TPtrC param;

	TInt error = KErrNone;

	TRAP(error, param.Set( ParamsL(aCommand)));

	if (error != KErrNone)

		return Error(error, TFR_KFmtErrBadCmd, &Keyphrase());

	//	check its' valid

	TLex parse(param);

	if (!parse.Eos() && !parse.Peek().IsSpace())

		return Error(error, TFR_KFmtErrBadCmd, &parse);

	//	remove any spaces and see if its got params

	parse.SkipSpace();

	if (parse.Eos())	// If no params, print out present connections.

		return error;

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

	//	Get transaction name, must not exceed 16 characters.

	TRAP(error, aTransName.Set(TfrLex::GetL(parse)));

	if ( error != KErrNone) 

		return Error(KErrArgument, TFR_KFmtErrBadCmd, &aTransName);

	//	check transaction name is valid length

	aTransName.Set(TfrLex::Peel(aTransName));

	if (aTransName.Length() > 16) 

		return Error(KErrArgument, THA_KErrParameterLong, &aTransName);

	if (aTransName.Length() <= 0)

		return Error(KErrArgument, TFR_KFmtErrMissingParams, &Keyphrase());

	return (KErrNone);

	}

TInt CCmdEndTransaction::ProcessL(const TDesC& aCommand)

	{

	// Complete the test machine - will then get the next cmd

	Machine()->CompleteRequest();

	TPtrC transname;

	TInt error = KErrNone;

	if (( error = ParseCmdArgs( aCommand, 

							    transname)) != KErrNone)

		return error;

	CAnyObject *obj = (CAnyObject *)Machine()->Domains()->Name(transname);

	if ((obj == NULL) || (obj->Tag() != THA_KHTTP_Transaction))

		return Error(KErrArgument, THA_KErrInvalidTransaction, &transname);

	CTestTransaction *transaction = (CTestTransaction *) obj->Ptr();

	transaction->CloseTransaction();

	delete transaction;

	Machine()->Domains()->Delete(transname);

	return error;

}

CCmdShowTransaction *CCmdShowTransaction::NewL(TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase)

	{

	CCmdShowTransaction *self = NewLC( aCommandId, aKeyphrase, aHelpPhrase);

	CleanupStack::Pop();

	return self; 

	}

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