// Copyright (c) 2007-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:

//

#include <ineturilistdef.h>

#include <tldlistdef.h>

#include "urilistinterface.h"

#include "sqldbaccessor.h"

#include "ineturiimpl.h"

#include "urilistwritestream.h"

#include "urilist.h"

#include "urilistinitializer.h"

#include "tldlistinitializer.h"

#include "uriqueryfilter.h"

#include "tldproperties.h"

#include <delimitedpath8.h>

#include "tldlist.h"

#include <swi/sisregistrysession.h>

#include <swi/sisregistryentry.h>

#include <bautils.h> 

#include <uriutils.h>

const TInt KMaxLength = 1024;

const TInt pkgId(0x2000A471);

_LIT(KRomDirectory, "z");

_LIT(KUriListFile, ":\\private\\20009D70\\ineturilist.xml");

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

_LIT(KPolicyFile, ":\\private\\20009D70\\tldpolicy.xml");

#endif	//SYMBIAN_ENABLE_SPLIT_HEADERS

CUriListInterface::CUriListInterface ()

	{

	}

CUriListInterface::~CUriListInterface ()

	{

	if ( iDbAccessor )

		{

		iDbAccessor->Release ();	

		}

	iStringPool.Close ();

	}

CUriListInterface* CUriListInterface::NewL ()

	{

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

	CleanupStack::PushL ( self );

	self->ConstructL ();

	CleanupStack::Pop ( self );

	return self;

	}

void CUriListInterface::ConstructL ()

	{

	iStringPool.OpenL ( URILIST::Table );

	iStringPool.OpenL ( TLDLIST::Table );

	iDbAccessor = CSqlDbAccessor::NewL ( iStringPool );

	InitializeDatabaseL ();

	}

/**

Add a new URI and its associated properties into the storage. 

@param aUriStream A stream to read the CInetUriImpl object.

@param aUriId URI Id value that will be returned to the caller

@param aPropId Property Id value that will be returned to the caller

*/

void CUriListInterface::AddUriL ( RReadStream& aUriStream, TInt& aUriId, TInt& aPropId )

	{	

	CInetUriImpl* inetUri = CInetUriImpl::NewL ();

	CleanupStack::PushL ( inetUri );

	inetUri->UnpackL ( aUriStream );

	InsertL ( *inetUri );

	aUriId = inetUri->UriId ();

	aPropId = inetUri->Properties().PropId ();

	CleanupStack::PopAndDestroy ( inetUri );	

	}

/**

Removes the properties from the URIPropertiesTbl. The function removes the URI from the 

URITbl table if it is not having a dependency. See the table structure

@param aUriId URI Id value 

@param aPropId Property Id value

*/

void CUriListInterface::RemoveUriL ( TInt aUriId, TInt aPropId )

	{

	iDbAccessor->BeginTransactionL ();

	// This is not to delete the object rather to do a rollback operation incase of a failure

	CleanupStack::PushL ( TCleanupItem ( CUriListInterface::RollbackTrans, iDbAccessor ) );

	// Delete from properties table

	DeleteL ( KUriPropsTblName(), URILIST::EPropId, aPropId );

	// The URI also need to be removed if it is not marked for another service type.

	// Check for dependency. 

	if ( CheckDependencyL( aUriId ) )

		{

		// No dependency. The URI also need to be removed			

		DeleteL ( KUriTblName(), URILIST::EId, aUriId );

		}	

	// Delete the same from view

	DeleteL ( KViewName(), URILIST::EPropId, aPropId );

	iDbAccessor->CommitTransactionL ();

	CleanupStack::Pop (); // iDbAccessor

	}

/**

Updates the listtype and favouritename. Only, these 2 properties can be modified.

@param aUriPropsId Property ID which uniquely identifies the row in the URIPropertiesTbl

@param aListType New Listtype 

@param aFavouriteName New favourite name for the URI

*/

void CUriListInterface::UpdateUriL ( TInt aUriPropsId, InetUriList::TListType aListType, const TDesC8& aFavouriteName )

	{	

	iDbAccessor->BeginTransactionL ();

	// This is not to delete the object rather to do a rollback operation incase of a failure

	CleanupStack::PushL ( TCleanupItem ( CUriListInterface::RollbackTrans, iDbAccessor ) );

	// Only update List Type & Favourite Name. Other properties are not allowed to update.

	if ( UpdateL ( KUriPropsTblName(), aUriPropsId, aListType, aFavouriteName ) == 0 )

		User::Leave ( InetUriList::KErrUriNotFound );

	User::LeaveIfError ( UpdateL ( KViewName(), aUriPropsId, aListType, aFavouriteName ) );

	iDbAccessor->CommitTransactionL ();

	CleanupStack::Pop (); // iDbAccessor	

	}

/**

Inserts the information into URITbl, URIPropertiesTbl & the URI view. Checks whether

the URI is already present in the storage and applies the blacklist/whitelist rule

before insertion. 

@param aInetUri URI information object. On return the new property id and URI id will be set.

*/

void CUriListInterface::InsertL ( CInetUriImpl& aInetUri )

	{

	TInt result = KErrNone;

	const TUriC8& uri ( aInetUri.Uri().Uri() );

	MDBTransaction* dbTrans = DoSearchExactUriLC ( uri, aInetUri.Properties().ServiceType() );

	if ( dbTrans->Next() )

		{		

		// URI already exists for the requested service type. 

		result = InetUriList::KErrUriAlreadyExists;

		}	

	User::LeaveIfError ( result );

	CleanupStack::PopAndDestroy (); // dbTrans

	// Now the URI can be added.

	iDbAccessor->BeginTransactionL ();

	// This is not to delete the object rather to do a rollback operation incase of a failure

	CleanupStack::PushL ( TCleanupItem ( CUriListInterface::RollbackTrans, iDbAccessor ) );

	TInt uriId = 0;

	if ( InsertIntoUriTblL ( aInetUri.Uri().Uri(), uriId ) == 0 )

		User::Leave ( InetUriList::KErrUriAddFailed );

	aInetUri.SetUriId ( uriId );

	// Now add the properties	

	TInt propId = 0;

	if ( InsertIntoUriPropsTblL ( aInetUri.UriId(), aInetUri.Properties(), propId ) == 0 )

		User::Leave ( InetUriList::KErrUriAddFailed );	

	aInetUri.Properties().SetPropId( propId );

	User::LeaveIfError ( InsertIntoViewL ( aInetUri ) );

	iDbAccessor->CommitTransactionL ();			

	CleanupStack::Pop (); // iDbAccessor	

	}

/**

Inserts the information into TLDTbl. Checks whether

the URI is already present in the storage and applies the blacklist/whitelist rule

before insertion. 

@param aTldPolicydata Tld information object.

*/

void CUriListInterface::InsertTldPolicyDataL ( CTldProperties& aTldPolicydata )

	{

	//First check whether such row is available

	//if yes dont insert.

	// Now the TLD Policy data can be added.

	iDbAccessor->BeginTransactionL ();

	// This is not to delete the object rather to do a rollback operation incase of a failure

	CleanupStack::PushL ( TCleanupItem ( CUriListInterface::RollbackTrans, iDbAccessor ) );

	//Inserts unique row 

	if( !IsDuplicateEntryL( aTldPolicydata )   )

		{

		InsertIntoTldTblL ( aTldPolicydata );

		}

	iDbAccessor->CommitTransactionL ();			

	CleanupStack::Pop (); // iDbAccessor	

	}

/**

Inserts the data into the URITbl. 

@param aUri URI object

@param [out] aUriId The URI will be filled upon successful insertion. This ID

	uniquelly indentifies the URI.

@return Returns the number of rows inserted. Normally 1. Otherwise returns with

		system-wide error code.

*/

TInt CUriListInterface::InsertIntoUriTblL ( const TUriC8& aUri, TInt& aUriId )

	{

	const TDesC8& id ( iStringPool.String (URILIST::EId,URILIST::Table).DesC() );

	aUriId = GetMaxIdValueL ( KUriTblName(), id ) + 1;

	_LIT8 ( KUriTblInsertStmt, "INSERT INTO %S VALUES (:V1, :V2, :V3, :V4, :V5, :V6, :V7, :V8)" );

	RBuf8 sqlStmt;

	sqlStmt.CreateL ( KMaxDbStmtLen );

	CleanupClosePushL ( sqlStmt );

	sqlStmt.Format ( KUriTblInsertStmt(), &(KUriTblName()) );

	MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( sqlStmt );

	CleanupStack::PopAndDestroy (); // sqlStmt

	CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );

	// We are having 8 parameters for this query. First bind the query with parameter position 0 

	// and so on

	dbTrans->BindIntL ( URILIST::EId, aUriId ); 

	dbTrans->BindTextL ( URILIST::EScheme, aUri.IsPresent(EUriScheme) ? aUri.Extract ( EUriScheme ) : KNullDesC8() );

	dbTrans->BindTextL ( URILIST::EUserInfo, aUri.IsPresent(EUriUserinfo) ? aUri.Extract ( EUriUserinfo ) : KNullDesC8() );

	dbTrans->BindTextL ( URILIST::EHost, aUri.IsPresent(EUriHost) ? aUri.Extract ( EUriHost ) : KNullDesC8() ); 

	dbTrans->BindTextL ( URILIST::EPort, aUri.IsPresent(EUriPort) ? aUri.Extract ( EUriPort ) : KNullDesC8() );

	dbTrans->BindTextL ( URILIST::EPath, aUri.IsPresent(EUriPath) ? aUri.Extract ( EUriPath ) : KNullDesC8() ); 

	dbTrans->BindTextL ( URILIST::EQuery, aUri.IsPresent(EUriQuery) ? aUri.Extract ( EUriQuery ) : KNullDesC8() );  

	dbTrans->BindTextL ( URILIST::EFragments, aUri.IsPresent(EUriFragment) ? aUri.Extract ( EUriFragment ) : KNullDesC8() );  				

	TInt result = dbTrans->ExecuteL ();

	CleanupStack::PopAndDestroy (); //dbTrans

	return result;

	}

/**

Inserts the data into the TLDTbl. 

@return Returns the number of rows inserted. Normally 1. Otherwise returns with

		system-wide error code.

*/

TInt CUriListInterface::InsertIntoTldTblL ( const CTldProperties& aTldProps )

	{

	_LIT8 ( KTldTblInsertStmt, "INSERT INTO %S VALUES ( :V1, :V2, :V3 )" );

	RBuf8 sqlStmt;

	sqlStmt.CreateL ( KMaxDbStmtLen );

	CleanupClosePushL ( sqlStmt );

	sqlStmt.Format ( KTldTblInsertStmt(), &(KTldTblName()) );

	MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( sqlStmt );

	CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );

	dbTrans->BindTextL ( TLDLIST::ETLDName, aTldProps.TldName() );

	TInt lt = static_cast<TInt> ( aTldProps.ListType() ) ;

	dbTrans->BindIntL ( TLDLIST::EListType, lt );

	dbTrans->BindTextL ( TLDLIST::ECharacterSet, aTldProps.CharacterSet() );

	TInt result = dbTrans->ExecuteL ();

	CleanupStack::PopAndDestroy (2); // sqlStmt, dbTrans

	return result;

	}

/**

Checks whether the duplicate entry in the TLDTbl. 

@return ETrue if already such row exist else retrns EFalse

*/

TBool CUriListInterface::IsDuplicateEntryL ( const CTldProperties& aTldProps )

	{

	_LIT8 ( KTldTblSearchStmt, "SELECT * FROM %S WHERE %S=:V1 and %S=:V2" );

	const TDesC8& KTldName (iStringPool.String (TLDLIST::ETLDName,TLDLIST::Table).DesC());

	const TDesC8& KTldListType (iStringPool.String (TLDLIST::EListType,TLDLIST::Table).DesC());

	RBuf8 sqlStmt;

	sqlStmt.CreateL ( KMaxDbStmtLen );

	CleanupClosePushL ( sqlStmt );

	sqlStmt.Format ( KTldTblSearchStmt(), &(KTldTblName()), &KTldName, &KTldListType  );

	MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( sqlStmt );

	CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );

	dbTrans->BindTextL ( TLDLIST::ETLDName, aTldProps.TldName() );

	TInt lt = static_cast<TInt> ( aTldProps.ListType() ) ;

	dbTrans->BindIntL ( TLDLIST::EListType, lt );

	TBool result( dbTrans->Next () );

	CleanupStack::PopAndDestroy (2); // sqlStmt, dbTrans

	return result;

	}

/**

Inserts the data into the URIPropertiesTbl. 

@param aUri URI object

@param [out] aUriId The URI will be filled upon successful insertion. This ID

	uniquelly indentifies the URI.

@return Returns the number of rows inserted. Normally 1. Otherwise returns with

		system-wide error code.

*/

TInt CUriListInterface::InsertIntoUriPropsTblL ( TInt aUriId, const CInetUriProperties& aUriProps, TInt& aPropId )

	{

	const TInt KMaxLen = 128;

	const TDesC8& propId ( iStringPool.String (URILIST::EPropId,URILIST::Table).DesC() );

	aPropId = GetMaxIdValueL ( KUriPropsTblName(), propId ) + 1;

	_LIT8 ( KInsertStmt, "INSERT INTO %S VALUES (%d, %d, %d, %d, %d, :V1)");

	RBuf8 queryBuf;

	CleanupClosePushL (queryBuf);

	queryBuf.CreateL ( KMaxLen );

	queryBuf.AppendFormat ( KInsertStmt, &(KUriPropsTblName()), aUriId, aPropId, aUriProps.ServiceType(), aUriProps.ListType(), aUriProps.Permission() );

	MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( queryBuf );

	CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );

	dbTrans->BindTextL ( 0, aUriProps.FavouriteName () ); // Bind with parameter index 0

	TInt result = dbTrans->ExecuteL ();

	CleanupStack::PopAndDestroy (2); // queryBuf, dbTrans

	return result;

	}

/**

Insert the data into the view. The view insertion will happen via a trigger. 

The SQLite views are read-only and cannot do any INSERT/DELETE/UPDATE operation directly.

@param aInetUri The URI information

@return KErrNone for success else return any of the system wide error code.

Note: The view insertion execution will not give the number of rows actualy 

inserted. It returns KErrNone

*/

TInt CUriListInterface::InsertIntoViewL ( const CInetUriImpl& aInetUri )

	{

	_LIT8 ( KUriViewInsertStmt, "INSERT INTO %S \

								VALUES (:V1, :V2, :V3, :V4, :V5, :V6, :V7, :V8, \

								:V9, :V10, :V11, :V12, :V13)" );

	RBuf8 sqlStmt;

	sqlStmt.CreateL ( KMaxDbStmtLen );

	CleanupClosePushL ( sqlStmt );

	sqlStmt.Format ( KUriViewInsertStmt(), &(KViewName()));

	MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( sqlStmt );

	CleanupStack::PopAndDestroy (); //sqlStmt

	CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );

	// We are having 8 parameters for this query. First bind the query with parameter position 0 

	// and so on

	dbTrans->BindIntL ( URILIST::EId, aInetUri.UriId() ); 

	TUriC8 uri ( aInetUri.Uri().Uri() );

	dbTrans->BindTextL ( URILIST::EScheme, uri.IsPresent(EUriScheme) ? uri.Extract ( EUriScheme ) : KNullDesC8() );

	dbTrans->BindTextL ( URILIST::EUserInfo, uri.IsPresent(EUriUserinfo) ? uri.Extract ( EUriUserinfo ) : KNullDesC8() );

	dbTrans->BindTextL ( URILIST::EHost, uri.IsPresent(EUriHost) ? uri.Extract ( EUriHost ) : KNullDesC8() ); 

	dbTrans->BindTextL ( URILIST::EPort, uri.IsPresent(EUriPort) ? uri.Extract ( EUriPort ) : KNullDesC8() );

	dbTrans->BindTextL ( URILIST::EPath, uri.IsPresent(EUriPath) ? uri.Extract ( EUriPath ) : KNullDesC8() ); 

	dbTrans->BindTextL ( URILIST::EQuery, uri.IsPresent(EUriQuery) ? uri.Extract ( EUriQuery ) : KNullDesC8() );  

	dbTrans->BindTextL ( URILIST::EFragments, uri.IsPresent(EUriFragment) ? uri.Extract ( EUriFragment ) : KNullDesC8() );  

	CInetUriProperties& properties = aInetUri.Properties ();

	dbTrans->BindIntL ( URILIST::EPropId - 1, properties.PropId() );

	dbTrans->BindIntL ( URILIST::EServiceType - 1, properties.ServiceType() );

	dbTrans->BindIntL ( URILIST::EListType - 1, properties.ListType() );

	dbTrans->BindIntL ( URILIST::EPermission - 1, properties.Permission() );

	dbTrans->BindTextL ( URILIST::EFavouriteName-1, properties.FavouriteName() );

	TInt result = dbTrans->ExecuteL ();

	CleanupStack::PopAndDestroy (); //dbTrans	

	return result;	

	}

/**

Updates the URI properties

@param aSchemaName Schema name - Could be table or view name

@param aPropId Property ID 

@param aListType new List type

@param aFavouritename new favourite name.

*/

TInt CUriListInterface::UpdateL ( const TDesC8& aSchemaName, TInt aPropId, InetUriList::TListType aListType, const TDesC8& aFavouriteName )

	{

	const TDesC8& propId ( iStringPool.String (URILIST::EPropId,URILIST::Table).DesC() );

	const TDesC8& listType (iStringPool.String (URILIST::EListType,URILIST::Table).DesC());

	const TDesC8& favouriteName (iStringPool.String (URILIST::EFavouriteName,URILIST::Table).DesC());

	// Only update List Type & Favourite Name. Other properties are not allowed to update.

	_LIT8 ( KUpdateStmt, "UPDATE %S SET %S=%d, %S=:V1 where %S=%d" );

	const TInt KMaxLen = 128;

	RBuf8 queryBuf;

	CleanupClosePushL ( queryBuf );

	queryBuf.CreateL ( KMaxLen );

	queryBuf.AppendFormat ( KUpdateStmt(), &aSchemaName, &listType, aListType, &favouriteName, &propId, aPropId );

	MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( queryBuf );

	CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );

	dbTrans->BindTextL ( 0, aFavouriteName );

	TInt result = dbTrans->ExecuteL ();

	CleanupStack::PopAndDestroy (2); // dbTrans, queryBuf

	return result;

	}

/**

Counts the number of URIs present in the storage for a given service type & list type

*/

TInt CUriListInterface::CountUriL ( InetUriList::TServiceType aServiceType, InetUriList::TListType aListType )

	{

	TQueryArgs args ( aServiceType, aListType );

	CUriQueryFilter* queryFilter = QueryL ( args );

	CleanupStack::PushL ( queryFilter );

	TInt count = queryFilter->MatchRecordCountL();

	CleanupStack::PopAndDestroy (); // queryFilter

	return count;

	}

/**

Returns the List type associated with the URI and a servicetype

*/

InetUriList::TListType CUriListInterface::GetListTypeL ( const TDesC8& aUri, InetUriList::TServiceType aSt )

	{

	TUriParser8 uriParser;

	User::LeaveIfError ( uriParser.Parse ( aUri ) );

	MDBTransaction* dbTrans = DoSearchExactUriLC ( uriParser, aSt );

	if ( !dbTrans->Next() )

		{		

		User::LeaveIfError ( InetUriList::KErrUriNotFound );

		}	

	InetUriList::TListType lt = static_cast < InetUriList::TListType > ( dbTrans->ColumnIntL ( URILIST::EListType - 1 ) );

	CleanupStack::PopAndDestroy (); // dbTrans

	return lt;

	}

/**

Delete the information from the given schema

@param aSchemaName Table or view name

@param aFieldPos The actual string index in the string table

@param aid ID

@return 

*/

void CUriListInterface::DeleteL ( const TDesC8& aSchemaName, TInt aFieldPos, TInt aId )

	{

	const TInt KMaxLen = 64;

	_LIT8 ( KDeleteStmt, "DELETE FROM %S where %S=%d" );

	const TDesC8& fieldName ( iStringPool.String (aFieldPos,URILIST::Table).DesC() );

	RBuf8 queryBuf;

	CleanupClosePushL ( queryBuf );

	queryBuf.CreateL ( KMaxLen );

	queryBuf.AppendFormat ( KDeleteStmt(), &aSchemaName, &fieldName, aId );

	MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( queryBuf );

	CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );

	dbTrans->ExecuteL ();

	CleanupStack::PopAndDestroy ( 2 ); // queryBuf, dbTrans	

	}

/**

The URI can be added for different servicetypes. Check if it is exist in the table.

*/

TBool CUriListInterface::CheckDependencyL ( TInt aId )

	{

	const TDesC8& id ( iStringPool.String (URILIST::EId,URILIST::Table).DesC() );	

	const TInt KMaxLen = 64;

	_LIT8 ( KQueryStmt, "SELECT * FROM %S where %S=%d" );

	RBuf8 queryBuf;

	CleanupClosePushL ( queryBuf );

	queryBuf.CreateL ( KMaxLen );

	queryBuf.AppendFormat ( KQueryStmt(), &(KUriTblName()), &id, aId );

	MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( queryBuf );

	CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );

	TBool result = dbTrans->Next();

	CleanupStack::PopAndDestroy (2); // queryBuf, dbTrans

	return result;

	}

/**

Get the Maximum Id value from the table.

*/

TInt CUriListInterface::GetMaxIdValueL ( const TDesC8& aTblName, const TDesC8& aFieldName )

	{

	const TInt KMaxLen = 64;

	_LIT8 ( KMaxValueQuery, "SELECT MAX(%S) from %S" );

	RBuf8 queryBuf;

	CleanupClosePushL ( queryBuf );

	queryBuf.CreateL ( KMaxLen );

	queryBuf.AppendFormat ( KMaxValueQuery, &aFieldName, &aTblName );

	TInt result = iDbAccessor->ExecuteScalarQueryL ( queryBuf );

	CleanupStack::PopAndDestroy (); //queryBuf 

	return result;

	}

/**

Destroys the transaction object

*/

void CUriListInterface::DestroyTransObj ( TAny* aPtr )

	{

	MDBTransaction* trans =	(MDBTransaction*)aPtr;

	trans->Release();

	}

/**

Rollback the transaction when a leave happens in insert/delete/update operation

*/

void CUriListInterface::RollbackTrans ( TAny* aPtr )

	{

	MDBAccessor* accessor = (MDBAccessor*)aPtr;

	accessor->RollbackTransaction();

	}

/**

Query for the URI based on service type and listtype. The servicetype and listtype 

will be extracted from aQueryArgs

*/

CUriQueryFilter* CUriListInterface::QueryL ( const TQueryArgs& aQueryArgs )

	{