/*

 * 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 the License "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: 

 * Implements a writable interface for UPS Database.

 *

 */

 /**

  @file

  @internalTechnology

  @released

 */

 #include "upsdbw.h"

 #include "upscommon.h"

 using namespace UserPromptService;

 CDecisionDbW::CDecisionDbW()

 /**

 	Constructor for writable decision database object

  */

 	{

 	}

 CDecisionDbW::~CDecisionDbW()

 /**

 	Destructor for writable decision database object

  */

 	{

 	iDatabase.Close();

 	delete iDbName;

 	delete iStore;

 	}

 EXPORT_C CDecisionDbW* CDecisionDbW::NewL(const TDesC& aDbName, RFs& aFs)

 /**

 	Creates a writable decision database object and connects to the database.

 	If the database does not exist or is corrupted, a new decision database is created.

 	The function leaves, if creation of the object or connection to the database fail.

 	@param	 aDbName The path of the decision database

 	@param   aFs     Handle to the file server session

 	@return  A pointer to the newly allocated database object, if creation and connection are successful. 

  */

 	{

 	CDecisionDbW* self = CDecisionDbW::NewLC(aDbName, aFs);

 	CleanupStack::Pop(self);

 	return self;

 	}

 EXPORT_C CDecisionDbW* CDecisionDbW::NewLC(const TDesC& aDbName, RFs& aFs)

 /**

 	Creates a writable decision database object and connects to the database.

 	If the database does not exist or is corrupted, a new decision database is created.

 	The function leaves, if creation of the object or connection to the database fail.

 	@param	aDbName The path of the decision database

 	param   aFs		Handle to the file server session

 	@return A pointer to the newly allocated database object, if creation and connection 

 			are successful. The pointer is also put onto the cleanup stack.

  */

 	{

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

 	CleanupStack::PushL(self);

 	self->ConstructL(aDbName, aFs);

 	return self;

 	}

 void CDecisionDbW::ConstructL(const TDesC& aDbName, RFs& aFs)

 /**

 	Second phase constructor for the decision database object. Connects to the decision database.

 	If the database does not existed or is corrupted, creates a new one. The function leaves,

 	if both database connection and creation fail.

 	@param aDbName The path of the decision database

 	@param aFs		Handle to the file server session

  */

 	{

 	//Construct the name of UPS decision database

 	iDbName = aDbName.AllocL();

 	//First try to open the decision database

 	TRAPD(error,OpenDatabaseL(aFs));

 	if((error == KErrNoMemory) || (error == KErrDiskFull))

 		{

 		User::Leave(error);

 		}

 	// Makes sure that DB file is writable. (DEF122590)

 	aFs.SetAtt(iDbName->Des(),0, KEntryAttReadOnly);

 	if(error != KErrNone)

 		{

 		DEBUG_PRINTF2(_L("%S database file does not exist or is corrupted."), iDbName);

 		//The decision database does not exist or is corrupted, create a new one

 		CreateDatabaseL(aFs);

 		//Create a decision table in the decision database

 		CreateTableL();

 		//Create an index on the decision table

 		CreateIndexL();

 		}

 	}

 void CDecisionDbW::OpenDatabaseL(RFs& aFs)

 /**

 	Opens the decision database.

 	@param aFs	Handle to the file server session

  */

 	{

 	DEBUG_PRINTF2(_L("%S database file is being opened."), iDbName);

 	iStore = CPermanentFileStore::OpenL(aFs, *iDbName, EFileRead|EFileWrite);

 	iDatabase.OpenL(iStore, iStore->Root());

 	//Database does exist. However, make sure that the decision table also exists

 	CDbTableNames *tables = iDatabase.TableNamesL();

 	CleanupStack::PushL(tables);

 	if(1 != tables->Count())

 		{

 		DEBUG_PRINTF(_L("The decision table could not be found in the database file!"));

 		User::Leave(KErrNotFound);

 		}

 	CleanupStack::PopAndDestroy(tables);

 	//OK. The decision table does exist. What about the decision index?

 	CDbIndexNames *indexes = iDatabase.IndexNamesL(KDecisionTable);

 	CleanupStack::PushL(indexes);

 	if(2 != indexes->Count())

 		{

 		DEBUG_PRINTF(_L("The index on the decision table is missing!"));

 		User::Leave(KErrNotFound);

 		}

 	CleanupStack::PopAndDestroy(indexes);

 	if(iDatabase.IsDamaged())

 		{

 		User::LeaveIfError(iDatabase.Recover());

 		}

 	DEBUG_PRINTF2(_L("%S database file has been opened successfully."), iDbName);

 	}

 void CDecisionDbW::CreateDatabaseL(RFs& aFs)

 /**

 	Creates a new, empty store database.

 	@param aFs	Handle to the file server session

  */

 	{

 	DEBUG_PRINTF2(_L("%S database is being created."), iDbName);

 	if(iStore)

 		{//if database file exists but the table does not, iStore has already been allocated. 

 		delete iStore;

 		iStore = 0;

 		iDatabase.Close();

 		}

 	//Create a file store

 	iStore = CPermanentFileStore::ReplaceL(aFs, *iDbName, EFileRead|EFileWrite);

 	iStore->SetTypeL(iStore->Layout());

 	//Create UPS Decision Database in the file store

 	TStreamId sId = iDatabase.CreateL(iStore);

 	iStore->SetRootL(sId);

 	//Commit the database creation

 	iStore->CommitL();

 	DEBUG_PRINTF2(_L("%S database has been created successfully."), iDbName);

 	}

 void CDecisionDbW::CreateTableL()

 /**

 	Creates the decision table in the decision database.

  */

 	{

 	DEBUG_PRINTF(_L("The Ups decision table is being created."));

 	// Create a table definition

 	CDbColSet* columns=CDbColSet::NewLC();

 	// add the columns to the definition

 	TDbCol clientSid(KColClientSid,EDbColUint32);

 	clientSid.iAttributes = TDbCol::ENotNull;				

 	columns->AddL(clientSid);

 	TDbCol evaluatorId(KColEvaluatorId,EDbColUint32);

 	evaluatorId.iAttributes = TDbCol::ENotNull;				

 	columns->AddL(evaluatorId);

 	TDbCol serviceId(KColServiceId,EDbColUint32);

 	serviceId.iAttributes=TDbCol::ENotNull;

 	columns->AddL(serviceId);

 	TDbCol serverSid(KColServerSid,EDbColUint32);

 	serverSid.iAttributes=TDbCol::ENotNull;

 	columns->AddL(serverSid);

 	TDbCol fingerprint(KColFingerprint,EDbColText8,KUpsMaxFingerprintLength );

 	columns->AddL(fingerprint);

 	TDbCol clientEntity(KColClientEntity,EDbColText8,KUpsMaxClientEntityLength);

 	columns->AddL(clientEntity);

 	TDbCol description(KColDescription,EDbColLongText);

 	columns->AddL(description);

 	TDbCol result(KColResult,EDbColInt8);

 	result.iAttributes=TDbCol::ENotNull;

 	columns->AddL(result);

 	TDbCol evaluatorInfo(KColEvaluatorInfo,EDbColUint32);

 	columns->AddL(evaluatorInfo);

 	TDbCol policyVersion(KColMajorPolicyVersion,EDbColUint16);

 	policyVersion.iAttributes=TDbCol::ENotNull;

 	columns->AddL(policyVersion);

 	TDbCol recordId(KColRecordId,EDbColUint32);

 	recordId.iAttributes=TDbCol::ENotNull|TDbCol::EAutoIncrement;

 	columns->AddL(recordId);

 	// Create a table with the table definition

 	User::LeaveIfError(iDatabase.CreateTable(KDecisionTable,*columns));

 	// cleanup the column set

 	CleanupStack::PopAndDestroy(columns);

 	DEBUG_PRINTF(_L("The Ups decision table has been created successfully."));

 	}

 void CDecisionDbW::CreateIndexL()

 /**

 	Creates an index on the decision table and makes it unique.

  */

 	{

 	DEBUG_PRINTF(_L("The Ups decision index is being created on the decision table."));

 	// create the index key

 	CDbKey* key=CDbKey::NewLC();

 	// add the key columns

 	key->AddL(TDbKeyCol(KColClientSid));

 	key->AddL(TDbKeyCol(KColEvaluatorId));

 	key->AddL(TDbKeyCol(KColServiceId));

 	key->AddL(TDbKeyCol(KColServerSid));

 	key->AddL(TDbKeyCol(KColFingerprint));

 	key->AddL(TDbKeyCol(KColClientEntity));

 	key->AddL(TDbKeyCol(KColMajorPolicyVersion));

 	//Make the index key unique

 	key->MakeUnique();

 	// create the primary index

 	User::LeaveIfError(iDatabase.CreateIndex(KPrimaryIndex,KDecisionTable,*key));

 	//Now create the second index on the record id

 	key->Clear();

 	// add the record id column

 	key->AddL(TDbKeyCol(KColRecordId));

 	key->MakeUnique();

 	// create the record id index

 	User::LeaveIfError(iDatabase.CreateIndex(KRecordIdIndex,KDecisionTable,*key));

 	// cleanup the key

 	CleanupStack::PopAndDestroy(key);

 	DEBUG_PRINTF(_L("The Ups decision index has been created successfully."));

 	}

 EXPORT_C void CDecisionDbW::DeleteDatabaseL(RFs& aFs)

 /**

 	Delete the decision database completely.

 	@param aFs	Handle to the file server session

  */

 	{

 	DEBUG_PRINTF2(_L("%S database is being deleted."),iDbName);

 	iDatabase.Close();

 	delete iStore;

 	iStore = 0;

 	User::LeaveIfError(aFs.Delete(*iDbName));

 	DEBUG_PRINTF2(_L("%S database has been deleted successfully."),iDbName);

 	}

 void CDecisionDbW::UpdateCurrentRowL(RDbTable& aTable, CDecisionRecord& aRecord)

 /**

 	Updates the current row of the rowset by using the values the provided decision record.

 	@param aTable  A table object which provides access to table data as a rowset.

 	@param aRecord A decision record object used to update the current row.

  */

 	{

 	//Use CDbColSet to set fields

 	CDbColSet* colSet = aTable.ColSetL();

 	CleanupStack::PushL(colSet);

 	//Set the fields of the empty row

 	aTable.SetColL(colSet->ColNo(KColClientSid)	 ,(TUint32)aRecord.iClientSid.iId);

 	aTable.SetColL(colSet->ColNo(KColEvaluatorId),(TUint32)aRecord.iEvaluatorId.iUid);

 	aTable.SetColL(colSet->ColNo(KColServiceId)  ,(TUint32)aRecord.iServiceId.iUid);

 	aTable.SetColL(colSet->ColNo(KColServerSid)	 ,(TUint32)aRecord.iServerSid.iId);

 	//Fingerprint may be null

 	if(aRecord.iFingerprint.Length() != 0)

 		{

 		aTable.SetColL(colSet->ColNo(KColFingerprint),aRecord.iFingerprint);

 		}

 	//ClientEntity may be null

 	if(aRecord.iClientEntity.Length() != 0)

 		{

 		aTable.SetColL(colSet->ColNo(KColClientEntity),aRecord.iClientEntity);

 		}

 	//Description may be null	

 	if(aRecord.iDescription.Length() != 0)

 		{

 		//A long column is written by using an RDbColStream

 		RDbColWriteStream str;

 		TDbColNo col = colSet->ColNo(KColDescription);

 		str.OpenLC(aTable,col);

 		str.WriteL(aRecord.iDescription);

 		str.Close();

 		CleanupStack::PopAndDestroy(&str);

 		}

 	aTable.SetColL(colSet->ColNo(KColResult),aRecord.iResult);

 	aTable.SetColL(colSet->ColNo(KColEvaluatorInfo),(TUint32)aRecord.iEvaluatorInfo);

 	aTable.SetColL(colSet->ColNo(KColMajorPolicyVersion),aRecord.iMajorPolicyVersion);

 	CleanupStack::PopAndDestroy(colSet);

 	}

 EXPORT_C void CDecisionDbW::CreateDecisionL(CDecisionRecord& aRecord)

 /**

 	Inserts a new decision record into the decision database.

 	@param aRecord A new decision record

  */

 	{

 	//Create a database table object

 	RDbTable dbTable;

 	User::LeaveIfError(dbTable.Open(iDatabase,KDecisionTable,dbTable.EInsertOnly));

 	CleanupClosePushL(dbTable);

 	//Set the rowset cursor to the beginning position

 	dbTable.Reset();

 	//Insert an empty row into the table

 	dbTable.InsertL();

 	//Set the fields of newly inserted row

 	UpdateCurrentRowL(dbTable, aRecord);

 	//Complete insertion

 	dbTable.PutL();

 	CleanupStack::Pop(&dbTable);

 	//Close the rowset

 	dbTable.Close();	 

 	}

 void CDecisionDbW::PrepareForSearchL(RDbTable& aTable, CDecisionFilter& aFilter, TDbSeekMultiKey<KIndexColumnNumber>& aSeekKey)

 /**

 	Opens the provided table object on the decision database and sets the decision index 

 	as the active index for this table. If successful, the rowset is reset to the beginning.

 	@param aTable  A table object which provides access to table data as a rowset.

 	@param aFilter A filter object which is used to set the decision index.

 	@return 	   The key value to lookup in the index.

  */

 	{

 	User::LeaveIfError(aTable.Open(iDatabase, KDecisionTable, aTable.EUpdatable));

 	TUint16 flags = KSetClientSid|KSetEvaluatorId|KSetServiceId|KSetServerSid|KSetFingerprint|KSetClientEntity|KSetMajorPolicyVersion;

 	TUint16 combinedFlags = (0x00FF) & (aFilter.iSetFlag[KPosClientSid]   | aFilter.iSetFlag[KPosEvaluatorId] |

 						     			aFilter.iSetFlag[KPosServiceId]   | aFilter.iSetFlag[KPosServerSid]   |

 						     			aFilter.iSetFlag[KPosFingerprint] | aFilter.iSetFlag[KPosClientEntity]|

 						     			aFilter.iSetFlag[KPosMajorPolicyVersion]);

 	//If any of these flags is not set, do not continue

 	if ((combinedFlags & flags) != flags)

 		{

 		DEBUG_PRINTF(_L("The provided filter does not have all required keys to look up a decision."));

 		User::Leave(KErrUpsMissingArgument);

 		}

 	aSeekKey.Add((TUint)aFilter.iClientSid.iId);

 	aSeekKey.Add((TUint)aFilter.iEvaluatorId.iUid);

 	aSeekKey.Add((TUint)aFilter.iServiceId.iUid);

 	aSeekKey.Add((TUint)aFilter.iServerSid.iId);

 	aSeekKey.Add(*aFilter.iFingerprint);

 	aSeekKey.Add(*aFilter.iClientEntity);

 	aSeekKey.Add(aFilter.iMajorPolicyVersion);

 	//Set the primary index

 	User::LeaveIfError(aTable.SetIndex(KPrimaryIndex));

 	}

 EXPORT_C CDecisionRecord* CDecisionDbW::GetDecisionL(CDecisionFilter& aFilter)

 /**

 	Gets a decision record from the decision database. The functions returns the first matched

 	record. All the methods of the filter object except the client entity should be supplied to 

 	get the intended decision record. If any other attribute of the filter object is missing, 

 	either no decision might be found or a wrong decision may be retrieved

 	@param aFilter A filter object whose client id, policy evaluator id, service id,

 	 			   server id, fingerprint (and client entity) attributes are set.

  */

 	{

 	//Define a database table object handle

 	RDbTable dbTable;

 	CleanupClosePushL(dbTable);

 	//Open the database table object and prepares it for searching

 	TDbSeekMultiKey<KIndexColumnNumber> seekKey;

 	PrepareForSearchL(dbTable,aFilter,seekKey);

 	//Define the decision record that will be returned

 	CDecisionRecord* retRecord(0);

 	if(dbTable.SeekL(seekKey))

 		{

 		//Result found

 		CDbColSet* colSet = dbTable.ColSetL();

 		CleanupStack::PushL(colSet);

 		dbTable.GetL();

 		retRecord = CDecisionView::GenerateRecordL(dbTable,colSet);

 		CleanupStack::PopAndDestroy(colSet);		

 		}

 	CleanupStack::PopAndDestroy(&dbTable);

 	return retRecord;

 	}

 EXPORT_C TBool CDecisionDbW::UpdateDecisionL(CDecisionFilter& aFilter, CDecisionRecord& aNewRecord)

 	{

 	//Define a database table object handle

 	RDbTable dbTable;

 	CleanupClosePushL(dbTable);

 	//Open the database table object and prepares it for searching

 	TDbSeekMultiKey<KIndexColumnNumber> seekKey;

 	PrepareForSearchL(dbTable,aFilter,seekKey);

 	TBool retValue = ETrue; //return value

 	if(dbTable.SeekL(seekKey))

 		{

 		//Get the current row

 		dbTable.GetL();

 		//Prepare it for update

 		dbTable.UpdateL();

 		//Set the new values

 		UpdateCurrentRowL(dbTable, aNewRecord);

 		//Commit the update

 		dbTable.PutL();

 		}

 	else

 		{

 		retValue = EFalse;

 		}

 	CleanupStack::PopAndDestroy(&dbTable);

 	return retValue;

 	}

 void CDecisionDbW::DoRemoveDecisionL(CDecisionFilter& aFilter)

 /**

 	Deletes a set of records from the decision database. This function is called 

 	by RemoveDecisionsL in a loop to be able to catch and repair index corruptions.

 	@param aFilter A filter object

  */

 	{

 	//Create the SQL statement

 	RBuf sqlStatement;

 	CreateSqlStatementLC(aFilter, sqlStatement);

 	RDbView dbView;

 	CleanupClosePushL(dbView);

 	User::LeaveIfError(dbView.Prepare(iDatabase,TDbQuery(sqlStatement),TDbWindow::EUnlimited));

 	User::LeaveIfError(dbView.EvaluateAll());

 	//Begin the delete transaction and lock the database

 	User::LeaveIfError(iDatabase.Begin());	

 	while(dbView.NextL())

 		{

 		dbView.DeleteL();

 		}

 	CleanupStack::PopAndDestroy(&dbView);		

 	CleanupStack::PopAndDestroy(&sqlStatement);

 	//Release the lock

 	TInt result = iDatabase.Commit();

 	if(KErrNone != result)

 		{

 		DEBUG_PRINTF2(_L("Removing a decision has returned with %d. Rollback is now in proggress."),result);

 		iDatabase.Rollback();

 		User::Leave(result);

 		}

 	}

 EXPORT_C void CDecisionDbW::RemoveDecisionsL(CDecisionFilter& aFilter)

 /**

 	Deletes a set of records from the decision database. It is possible to delete a specific

 	decision record or a set of records based on a given filter. While this function is in

 	progress, the database is locked not to lead to an inconsistent data retrieving. If there

 	is any index corruption in the decision able, it is tried to be repaired automatically.

 	@param aFilter A filter object

  */

 	{

 	TInt loopCount=1;

 	TInt error;

 	do

 		{

 		++loopCount;

 		TRAP(error,DoRemoveDecisionL(aFilter));

 		if(error == KErrCorrupt)

 			{

 			DEBUG_PRINTF2(_L("The database is corrupted and being recovered. Try %d"),loopCount);

 			error = iDatabase.Recover(); //Recover() may fail, so update error

 			}

 		}while(error==KErrCorrupt && loopCount<2);

 	User::LeaveIfError(error);

 	}

 EXPORT_C CDecisionDbCompactor *CDecisionDbW::PrepareCompactionLC()

 /**

 	Creates a database compaction object to perform asynchronous compaction on the database.

 	@return A pointer to the newly created database compaction object

 			The pointer is also put onto the cleanup stack.

  */

 	{

 	DEBUG_PRINTF(_L("The Ups database is being compacted."));

 	CDecisionDbCompactor *compactor = CDecisionDbCompactor::NewLC();

 	User::LeaveIfError(compactor->iDbIncremental.Compact(iDatabase,compactor->iStep()));

 	return compactor;

 	}