// 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 "LogServView.h"

#include "logpackage.h"

#include "logservpanic.h"

#include "LogServBackupInterface.h"

#include "LogServViewChangeManager.h"

#include "LogServDatabaseChangeInterface.h"

#include "LogServCacheTypes.h"

#include "LogServSqlStrings.h"

#include "LOGFILTQ.H"

// Constants

const TInt KLogViewContentsGranuality = 20;

const TInt KLogViewLockStatusEventGranularity = 3;

TDbColNo CLogServViewBase::iIdColNo = 0;

TDbColNo CLogServViewBase::iTypeColNo = 0;

TDbColNo CLogServViewBase::iFlagColNo[] = {0, 0, 0, 0};

TDbColNo CLogServViewRecent::iIdColNo = 0;

TDbColNo CLogServViewRecent::iRecentColNo = 0;

TDbColNo CLogServViewRecent::iDuplicateColNo = 0;

//diagnostic message for the platform security

const char* KIgnoreDiagnostic = "This diagnostic message does not indicate an error, please ignore it";

/////////////////////////////////////////////////////////////////////////////////////////

// -----> CLogServViewBase (source)

/////////////////////////////////////////////////////////////////////////////////////////

CLogServViewBase::CLogServViewBase(MLogServDatabaseTransactionInterface& aDatabase, 

                                   MLogServBackupInterface& aBackupInterface, 

                                   CLogPackage& aPackage, TLogViewType aType, TLogViewId aViewId, 

                                   const RMessage2& aMessage) :

    iDatabase(aDatabase), 

    iPackage(aPackage),

    iBackupInterface(aBackupInterface), 

    iType(aType), 

    iViewId(aViewId), 

    iMessage (aMessage)

	{

	}

CLogServViewBase::~CLogServViewBase()

	{

	iDatabase.DTIChangeInterface().DCIRequestChangeNotificationsCancel(*this);

	iBackupInterface.BIObserverRemove(*this);

	//

	iViewContents.Close();

	//	

	iStandardTypeSecurityCache.Close();

	//

	delete iLockChangeObserver;

	delete iSql;

	delete iChangeManager;

	}

void CLogServViewBase::ConstructL()

	{

	// Handles changes for this view

	iChangeManager = CLogServViewChangeManager::NewL(iDatabase.DTIChangeInterface());

	// Register for change events

	iDatabase.DTIChangeInterface().DCIRequestChangeNotificationsL(*this);

	// Register for backup events

	iBackupInterface.BIObserverAddL(*this, MLogServBackupInterface::EObjectView);

	// Observes when the view is locked/unlocked due to a backup

	iLockChangeObserver = CLogServViewLockObserver::NewL(iBackupInterface);

	const RArray<TUid>& arrTUids = iDatabase.DTIUidsOfStandardTypes();

	TInt count = arrTUids.Count();

	iStandardTypeSecurityCache.ReserveL(count);

	for(TInt i=0; i < count; i++)

		{

		SStandardTypeSecurity securitySetting;

		securitySetting.eventType = arrTUids[i];

		securitySetting.readAccess = iDatabase.DTIIsAllowed(EReadOp, iMessage, arrTUids[i], KIgnoreDiagnostic);

		securitySetting.writeAccess = iDatabase.DTIIsAllowed(EWriteOp, iMessage, arrTUids[i], KIgnoreDiagnostic);

		TInt err = iStandardTypeSecurityCache.Append(securitySetting);	

        __ASSERT_ALWAYS(err == KErrNone, Panic(ELogArrayReserved));

		}

	}

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

void CLogServViewBase::DCOHandleChangeEventsL(const CLogChangeDefinition& aChanges)

	{

	// Just return if the view isn't setup

	if	(!iSql)

		return;

	TRAPD(error, DoHandleChangeEventsL(aChanges));

	if	(error != KErrNone)

		{

		iViewContents.Close();

	    iViewContentsReady = EFalse;

		iRebuildViewContents = ETrue;

		}

	}

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

void CLogServViewBase::BOHandleEventL(TLogServBackupEvent aEvent)

	{

	switch(aEvent)

		{

	case EBackupStarting:

		iViewContents.Close();

	    iViewContentsReady = EFalse;

		break;

	case EBackupEnded:

		RebuildViewL();

		break;

		}

	}

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

#pragma BullseyeCoverage off

/**

Remove an entry from the view.

By default you can't remove an event from a view.

*/

void CLogServViewBase::RemoveL(const RMessage2& /*aMessage*/)

	{

	User::Leave(KErrNotSupported);

	}

/**

By default you can't clear duplicates from a view

*/

void CLogServViewBase::ClearDuplicatesL(const RMessage2& /*aMessage*/)

	{

	User::Leave(KErrNotSupported);

	}

#pragma BullseyeCoverage on

/**

Set the flags of all the entries in the view.

*/

void CLogServViewBase::SetFlagsL(const RMessage2& aMessage)

	{

	if	(ViewIsReady())

		{

		// Flags from client

		const TLogFlags flags = static_cast<TLogFlags>(aMessage.Int2());

		RLogDbView view;

		view.PrepareLC(iDatabase.DTIDatabase(), *iSql);

		InitializeColumnsL(view);

		if(view.FirstL())

			{

            iDatabase.DTIBeginWithRollBackProtectionLC();

			// Iterate through the events

			do

				{

				// Get current event id

				view.GetL();

				const TLogId id = view.ColInt32(CLogServViewBase::iIdColNo);

				TUint8 eventTypeIndex = view.ColUint8(CLogServViewBase::iTypeColNo);

				if(IsAllowed(EWriteOp, eventTypeIndex))

					{

					// Make the change

					view.UpdateL();

		            TInt bit = KLogFlagsCount;

		            while(bit--)

		                {

                        const TBool flagIsSet = flags & (0x1 << bit) ? 1 : 0;

		                view.SetColL(CLogServViewBase::iFlagColNo[bit], flagIsSet);

		                }

					view.PutL();

					iDatabase.DTIChangeInterface().DCISubmitChangedEventContextL(ELogChangeTypeEventChanged, id);

					}

				}

			while(view.NextL());

			iDatabase.DTICommitAndCancelRollbackProtectionL();

			}

		CleanupStack::PopAndDestroy(&view);

		}

	else

		::PanicClientL(aMessage, ELogViewRecentViewNotYetReadyForFlagSetting);

	}

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

/**

The client has requested change notifications

*/

void CLogServViewBase::RequestChangeNotifications(const RMessage2& aMessage)

	{

	iChangeManager->RequestChangeNotifications(aMessage);

	}

/**

The client has cancelled a previous change notification request

*/

void CLogServViewBase::RequestChangeNotificationsCancel()

	{

	iChangeManager->RequestChangeNotificationsCancel();

	}

/**

The client has requested lock status change notifications

*/

void CLogServViewBase::RequestLockStatusChanges(const RMessage2& aMessage)

	{

	iLockChangeObserver->RequestLockStatusChanges(aMessage);

	}

/**

The client has cancelled a previous change notification request

*/

void CLogServViewBase::RequestLockStatusChangesCancel()

	{

	iLockChangeObserver->RequestLockStatusChangesCancel();

	}

/**

The client has requested the current list of changes

*/

void CLogServViewBase::RequestChangesL(const RMessage2& aMessage)

	{

	if	(!iSql)

		::PanicClientL(aMessage, ELogViewNotSetupForChangesFetch);

	else

		iChangeManager->DeliverChangesL(aMessage);

	}

/**

Set up the server-side view based upon the client-side filter. This

method essentially fetches a client-side filter and then dynamically

executes the associated SELECT statement on the database to build up

a view. This view is then cached in terms of the entry ids (iViewContents).

*/

void CLogServViewBase::SetupL(const RMessage2& aMessage, TLogFilterConstructionType aFilterType)

	{

	// Get the query string

	const TPtrC pSQL(GetQueryStringL(aMessage, aFilterType));

	HBufC* buf = pSQL.AllocLC();

	// Setup the contents

	PrepareViewContentsL(pSQL);

	// Tidy up

	CleanupStack::Pop(buf);

	delete iSql;

	iSql = buf;

	}

/**

Returns the number of entries in this view

*/

TInt CLogServViewBase::Count() const

	{

	return const_cast<CLogServViewBase*>(this)->RebuildViewContentsIfNecessary() ? 0 : iViewContents.Count(); 

	}

/**

Get the log id at the specified index

*/

TLogId CLogServViewBase::At(TInt aIndex) const

	{

	return (TUint)aIndex < iViewContents.Count() ? iViewContents[aIndex] : KLogNullId;   

	}

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

void CLogServViewBase::DestroyList(TAny *aPtr)

	{

	CLogFilterList* filter = reinterpret_cast<CLogFilterList*>(aPtr);

	filter->ResetAndDestroy();

	delete filter;

	}

void CLogServViewBase::InitializeColumnsL(RDbRowSet& aRowSet)

    {

    if(CLogServViewBase::iIdColNo == 0)

        {

        CDbColSet* colset = aRowSet.ColSetL();

        CLogServViewBase::iIdColNo = colset->ColNo(KLogFieldIdString);

        CLogServViewBase::iTypeColNo = colset->ColNo(KLogFieldEventTypeString);

        for(TInt i=0;i<KLogFlagsCount;++i)

            {

            TDbColName colname;

            colname.Format(KLogFieldEventFlagString, i + 1);

            CLogServViewBase::iFlagColNo[i] = colset->ColNo(colname);

            __ASSERT_DEBUG(CLogServViewBase::iFlagColNo[i] > 0, User::Invariant());

            }

        delete colset;

        }

    __ASSERT_DEBUG(CLogServViewBase::iIdColNo > 0 && CLogServViewBase::iTypeColNo > 0, User::Invariant());  

    }

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////

void CLogServViewBase::ResetViewContentsL(RDbRowSet& aRowSet)

	{

	// Get the view contents

	RArray<TLogId> viewContents(KLogViewContentsGranuality);

	CleanupClosePushL(viewContents);

	viewContents.ReserveL(aRowSet.CountL());

	if(aRowSet.FirstL())

		{

		do

			{

			// Get the id at the current position

			aRowSet.GetL();

			const TLogId id = aRowSet.ColInt32(CLogServViewBase::iIdColNo);

			TUint8 eventTypeIndex = aRowSet.ColUint8(CLogServViewBase::iTypeColNo);

			if(IsAllowed(EReadOp, eventTypeIndex))

			    {

				TInt err = viewContents.Append(id);

		        __ASSERT_ALWAYS(err == KErrNone, Panic(ELogArrayReserved));

			    }

			}

		while(aRowSet.NextL());

		}

	// Tidy up - don't leave from below here

    CleanupStack::Pop(&viewContents);

	iViewContents.Close();

	iViewContents = viewContents;

    iViewContentsReady = ETrue;

	}

void CLogServViewBase::PrepareViewContentsL(const TDesC& aSQL)

	{

	// Generate the view

    RLogDbView view;

    view.PrepareLC(iDatabase.DTIDatabase(), aSQL);

    InitializeColumnsL(view);

	// Reset the view

	ResetViewContentsL(view);

	CleanupStack::PopAndDestroy(&view);

	}

void CLogServViewBase::RebuildViewL()

	{

	if	(iSql && iSql->Length())

		PrepareViewContentsL(*iSql);

	}

//

//  The last change notification indication was not handled correctly.

//  Attempt to re-initialise the view

//

TInt CLogServViewBase::RebuildViewContentsIfNecessary()

	{

	TInt error = KErrNone;

	//

	if	(iRebuildViewContents && iSql && iSql->Length())

		{

		TRAP(error, 

			RebuildViewL();

			// The view is okay now

			iRebuildViewContents = EFalse;

			);

		}

	return error;

	}

void CLogServViewBase::DoHandleChangeEventsL(const CLogChangeDefinition& aChanges)

	{

    if(!ViewIsReady())

        {

        return;

        }

	// Generate the view

    RLogDbView view;

    view.PrepareLC(iDatabase.DTIDatabase(), *iSql);

    InitializeColumnsL(view);

	_LIT(KLogIdQuery, "Id = %d");

	TBuf<15> find;

	TInt changeIndex;

	// Prepare for a change transaction

	iChangeManager->ChangeTransactionPrepare();

	const TInt count = aChanges.Count();

	for(TInt i=0; i<count; i++)

		{

		// Fetch the change details

		TLogId logId = KLogNullId;

		TLogDatabaseChangeType type = aChanges.At(i, logId);

		// Mark the insertion position as 'not found'

		changeIndex = KErrNotFound;

		// Format the find query

		find.Format(KLogIdQuery, logId);

		// Handle the various change descriptions

		switch(type)

			{

		case ELogChangeTypeEventAdded:

			{

			__ASSERT_DEBUG(iViewContents.Find(logId) == KErrNotFound, Panic(ELogEventAlreadyInView));

			// See if the event is in the view

			if(view.FirstL())

				{

				const TDbQuery dbQuery(find);

				changeIndex = view.FindL(RDbRowSet::EForwards, dbQuery);

				if	(changeIndex >= 0)

					{

					view.GetL();

					TUint8 eventTypeIndex = view.ColUint8(CLogServViewBase::iTypeColNo);

					if (IsAllowed(EReadOp, eventTypeIndex))

						User::LeaveIfError(iViewContents.Insert(logId, changeIndex));

					iChangeManager->ChangeTransactionSubmitL(logId, ELogChangeTypeEventAdded, changeIndex);

					}

				}

			}

			break;

		case ELogChangeTypeEventChanged:

		case ELogChangeTypeEventChangedHidden:

			{

			// See if the event is in the view

			if	(view.FirstL() && (changeIndex = view.FindL(RDbRowSet::EForwards, TDbQuery(find))) >= KErrNone)

				{

				// If the event was already in the view then it has changed otherwise it's been added

				const TInt findIndex = iViewContents.Find(logId);

				if	(findIndex >= KErrNone)

					{

					// If the item that changed also caused its position within the view to be altered

					// then we need to simulate a delete, followed by an addition

					if	(findIndex != changeIndex)

						{

						iChangeManager->ChangeTransactionSubmitL(logId, ELogChangeTypeEventDeleted, findIndex);

						iChangeManager->ChangeTransactionSubmitL(logId, ELogChangeTypeEventAdded, changeIndex);

						}

					// Only tell the view if the CLogEvent has changed

					else if (type != ELogChangeTypeEventChangedHidden)

						{

						iChangeManager->ChangeTransactionSubmitL(logId, ELogChangeTypeEventChanged, changeIndex);

						}

					}

				else

					{

					User::LeaveIfError(iViewContents.Insert(logId, changeIndex));

					iChangeManager->ChangeTransactionSubmitL(logId, ELogChangeTypeEventAdded, changeIndex);

					// Update the type to indicate that this change action

					// really resulted in an addition

					type = ELogChangeTypeEventAdded;

					}

				}

			else

				{

				changeIndex = iViewContents.Find(logId);

				// If it used to be in the view then it's been removed because it's 

				// not in there anymore

				if	(changeIndex >= KErrNone)

					{

					iViewContents.Remove(changeIndex);

					iChangeManager->ChangeTransactionSubmitL(logId, ELogChangeTypeEventDeleted, changeIndex);

					// Update the type to indicate that this change action

					// really resulted in a deletion

					type = ELogChangeTypeEventDeleted;

					}

				}

			}

			break;

		case ELogChangeTypeEventDeleted:

			{

			changeIndex = iViewContents.Find(logId);

			// If it used to be in the view then tell it about the deletion

			if	(changeIndex >= KErrNone)

				{

				iViewContents.Remove(changeIndex);

				iChangeManager->ChangeTransactionSubmitL(logId, ELogChangeTypeEventDeleted, changeIndex);

				}

			}

			break;

		case ELogChangeTypeLogCleared:

			{

			RebuildViewL();

			iChangeManager->ChangeTransactionSubmitL(logId, ELogChangeTypeLogCleared, 0);

			}

			break;

		default:

			__ASSERT_DEBUG(EFalse, Panic(ELogUnrecognizedChangeType));

			break;

			}

		}

	CleanupStack::PopAndDestroy(&view);

	// Commit the transaction. Will notify client if necessary

	iChangeManager->ChangeTransactionCommitL();

	}

TBool CLogServViewBase::IsAllowed(TEventOp aEventOp, TUint8 aEventTypeIndex)

	{