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

// Comms Database Table View defintions

// 

//

/**

 @file

 @deprecated since v9.1. Functionality is replaced with commsdat.

*/

#include <cdbtemp.h>

#include <commdb.h>

#include <cdbpreftable.h>

#include <commsdat_partner.h>

#include <commsdattypesv1_1_partner.h>

#include "commdb_impl.H"

#include "Commsdat_Log.h"

#include "commsdattypeinfov1_1_internal.h"

const TInt KFirstRecord = 0;

// Additional funtions to implement Connection Preference table protection - in a separate

// class so as not to break BC.

CCommDbTableExtension::CCommDbTableExtension()

/**

Constructor

*/

    {

    }

CCommDbTableExtension* CCommDbTableExtension::NewL()

	{

	CCommDbTableExtension* self = new(ELeave) CCommDbTableExtension;

	TInt err = self->iCommitSeqProperty.Attach(KUidCommsDatStatusEvent, KCommsDatStatusEventCommitSeq);

	if(err != KErrNone)

		{

		delete self;

		User::Leave(err);

		}

	return self;

	}

void CCommDbTableExtension::GetRecordInfoL(const TDesC& aColumn, TDbColType& aColType, TUint32& aAttrib)

	{

	CMDBRecordSetBase* recSet = GetRecordSetL();

	TBuf<KCommsDbSvrMaxColumnNameLength> buf; // This holds Column name

	TBool found(EFalse);

	// create dummy record to read info from it

	CMDBRecordBase* dummyRecord = CCDRecordBase::RecordFactoryL(recSet->TypeId());

	const SRecordTypeInfo* recordInfo = dummyRecord->GetRecordInfo();

	// Loop through all the columns of the record

	while(recordInfo->iTypeId != 0 && !found)

		{

		// Get name of the field into buffer

		buf = recordInfo->iTypeName;

		if(buf.CompareF(aColumn) == 0)

			{

			found = ETrue;

			}

		else

			{

			// Switch to Next column

			recordInfo++;

			}

		}

	// check if column is not found

	if(!found)

		{

		delete dummyRecord;

		User::Leave(KErrNotFound);

		}

	else

		{

		aColType = GetColType(recordInfo->iValType);

		recordInfo->iTypeAttr == ENotNull ? aAttrib = TDbCol::ENotNull : aAttrib = 0;

		}

	delete dummyRecord;

	}

TDbColType CCommDbTableExtension::GetColType(TInt aType)

    {

    TDbColType ret;

    switch(aType)

        {

        case EText:

        case EMedText:

            ret = EDbColText16;

            break;

        case ELongText:

            ret = EDbColLongText;

            break;

        case EDesC8:

            ret = EDbColText8;

            break;

        case EUint32:

            ret = EDbColUint32;

            break;

        case EInt:

            ret = EDbColUint32;

            break;

        case EBool:

            ret = EDbColBit;

            break;

        default:

            ret = EDbColInt32;

        }

    return ret;

    }

TInt CCommDbTableExtension::GetMaxTypeLength(TInt aType)

    {

    TInt ret;

    switch(aType)

        {

        case EText:

            ret = KMaxTextLength;

            break;

        case EDesC8:

            ret = KMaxTextLength;

            break;

        case EUint32:

            ret = KMaxNumLength;

            break;

        case EInt:

            ret = KMaxNumLength;

            break;

        case EBool:

            ret = KMaxNumLength;

            break;

        case ELongText:

            ret = KMaxLongTextLength;

            break;

        case EMedText:

            ret = KMaxMedTextLength;

            break;

        default:

            ret = 0;

        }

    return ret;

    }

void CCommDbTableExtension::UpdateLastCommitSeq()

	{

	// Update the global commit sequence, for detecting possible changes when deciding whether to refresh records

	TInt currCommitSeq;

    if(iCommitSeqProperty.Get(currCommitSeq) == KErrNone)

		{

		iLastCommitSeq = currCommitSeq;

		}

	}

TInt CCommDbTableExtension::MaybeRefreshCurrentRecord(CMDBSession& aDbs)

	{

	// If the global commit sequence number differs from the last one set or observed by us then we need to refresh to ensure we

	// acquire any relevant changes

	TInt err = KErrNone;

	TInt currCommitSeq = iLastCommitSeq;

    if(iCommitSeqProperty.Get(currCommitSeq) != KErrNone || currCommitSeq != iLastCommitSeq)

		{

	    TRAP(err,iCurrentRecord->RefreshL(aDbs));

		if(err == KErrNone)

			{

			iLastCommitSeq = currCommitSeq;

			}

		}

	return err;

	}

TInt CCommDbTableExtension::GotoFirstRecord(CMDBSession& aDbs)

    {

	TInt err(KErrNotFound);

	TInt countContRec = iRecordSetContainer->iRecords.Count();

    if (iRecordSetContainer && countContRec)

        {

		// set up stating point

		iCurrentRecord = NULL;

		// set up first valid record

		TInt valid = FindFirstNextValidRecord(ETrue);

		if(valid)

			{

			// save current record before change

			CMDBRecordBase* currRecBackup(iCurrentRecord);

            if ( iCurrentRecord->RecordId() == KCDDefaultRecord  &&

                 (iCurrentRecord->Attributes() & ECDHidden ) &&

                 ! aDbs.IsSetAttributeMask(ECDHidden) )

                {

                err = GotoNextRecord(aDbs); 

                }

            else 

                {

			    err = MaybeRefreshCurrentRecord(aDbs);

				if (err != KErrNone) 

					{

					__FLOG_STATIC1(KLogComponent, KCommDbShim, _L("CCommDbTableExtension::GotoFirstRecord failed to Refresh the data Err=%d"),err);

					iCurrentRecord = currRecBackup;

					}

                }

			}

		iEndOfTableRecordBackup = NULL;

		iBeginingOfTableRecordBackup = NULL;

        }

    // record set is empty

    return err;

    }

TInt CCommDbTableExtension::GotoNextRecord(CMDBSession& aDbs)

    {

    TInt err(KErrNone);

	TInt currIndex(0);

	if (!iRecordSetContainer) 

		{

		return KErrNotFound;

		}

    if (iCurrentRecord)

        {

        TInt count = iRecordSetContainer->iRecords.Count();

		currIndex = iRecordSetContainer->iRecords.Find(iCurrentRecord);

        if (currIndex == count-1)

            {

            // record set is either empty or going out of scope

            err = KErrNotFound;

			// the marker is going beyond end of the table, so backup last record and use the value as end marker

			iEndOfTableRecordBackup = iCurrentRecord;

			iCurrentRecord = NULL;

            }

        else

            {

			// save current record before change

			CMDBRecordBase* currRecBackup(iCurrentRecord);

			// set up first next valid record

			TInt valid = FindFirstNextValidRecord(EFalse);

			if (valid) 

				{

			    err = MaybeRefreshCurrentRecord(aDbs);

				if (err != KErrNone) 

					{

					// return to status prior to failure

					iCurrentRecord = currRecBackup;

					__FLOG_STATIC1(KLogComponent, KCommDbShim, _L("CCommDbTableExtension::GotoNextRecord failed to Refresh the data Err=%d"),err);

					}

				}

			else

				{

				err = KErrNotFound;

				}

            }

        }

    else

    	{

		// if position was on the begining of the table then retrieve back first record and set up begining of table marker to null

        if (iBeginingOfTableRecordBackup)

			{

			iCurrentRecord = iBeginingOfTableRecordBackup;

			iBeginingOfTableRecordBackup = NULL;

			}

		else

	        {

	        err = KErrNotFound;

	        }

    	}

    return err;

    }

TInt CCommDbTableExtension::GotoPreviousRecord(CMDBSession& aDbs)

    {

    TInt err = KErrNone;

	if (!iRecordSetContainer) 

		{

		return KErrNotFound;

		}

    if (iCurrentRecord)

        {

        const TInt count = iRecordSetContainer->iRecords.Count();

		TInt currIndex = iRecordSetContainer->iRecords.Find(iCurrentRecord);

        if (currIndex == 0)

            {

            // record set is either empty or going out of scope

            err = KErrNotFound;

            }

        else

            {

			// save current record before change

			CMDBRecordBase* currRecBackup(iCurrentRecord);

			// set up first prev valid record

			TInt valid = FindFirstPrevValidRecord();

			if (valid) 

				{

			    err = MaybeRefreshCurrentRecord(aDbs);

				if (err != KErrNone) 

					{

					// return to status prior to failure

					iCurrentRecord = currRecBackup;

					__FLOG_STATIC1(KLogComponent, KCommDbShim, _L("CCommDbTableExtension::GotoPreviousRecord failed to Refresh the data Err=%d"),err);

					}

				}

			else

				{

				err = KErrNotFound;

				}

            }

        }

    else

        {

		// if position was on the end of the table then retrieve back last record and set up end of table marker to null

        if (iEndOfTableRecordBackup) 

			{

			iCurrentRecord = iEndOfTableRecordBackup;

			iEndOfTableRecordBackup = NULL;

			}

		else

			{

	        err = KErrNotFound;

			}

        }

    return err;

    }

void CCommDbTableExtension::InsertConnPrefRecordL(CCDConnectionPrefsRecord* aConnPref, CMDBSession& aDbs)

	{

	__FLOG_STATIC0(KLogComponent, KCommDbShim, _L("CCommDbTableExtension::InsertConnPrefRecordL -> Entry Point"));

	CMDBRecordSetBase* recSet = GetRecordSetL();

	// store newly created record

	aConnPref->SetRecordId(KCDNewRecordRequest);

	aConnPref->StoreL(aDbs);

	User::LeaveIfError(recSet->iRecords.Append(aConnPref));

	iCurrentRecord = recSet->iRecords[recSet->iRecords.Count()-1];

	TInt index = iDeletedRecords.Find(iCurrentRecord->RecordId());

	// check if inserted record has the same record id as previously deleted record	

	if(index>=0)

		{

		iDeletedRecords.Remove(index);

		}

	SortByRank();

	__FLOG_STATIC0(KLogComponent, KCommDbShim, _L("CCommDbTableExtension::InsertConnPrefRecordL -> Record Inserted"));

	}

TBool CCommDbTableExtension::IsGenericRecord(TMDBElementId aElementId) const

    {

    const TMDBElementId tableType = (aElementId & KCDMaskShowRecordType);

    return (tableType >= KCDInitialUDefRecordType);

    }

void CCommDbTableExtension::InsertRecordL(TBool aCopy, TUint32& aId, CMDBSession& aDbs, TBool aIsTemplate)

/**

Deletes the current record from commsdat and from queue.

Updates the value of record index.

*/

    {

	CMDBRecordSetBase* recSet = GetRecordSetL();

	// storing empty string in order to get RecordId for newly inserted record

	CMDBRecordBase* newRecord;

	if(aCopy)

		{

		CMDBRecordBase* record = GetCurrentRecordL();

		newRecord = CCDRecordBase::CreateCopyRecordL(*record);

		CleanupStack::PushL(newRecord);

		if(IsGenericRecord(newRecord->ElementId()))

			{

			newRecord->LoadL(aDbs);

			}		

		}

	else

		{

		newRecord = CCDRecordBase::RecordFactoryL(recSet->TypeId());

		CleanupStack::PushL(newRecord);

		if(IsGenericRecord(newRecord->ElementId()))

			{

			newRecord->LoadL(aDbs);

			}	

		}

    TBool removeHiddenMask = EFalse;

	if(aIsTemplate)

		{

		// this will mark record as template record

		newRecord->SetRecordId(KCDDefaultRecord);

        if (! aDbs.IsSetAttributeMask(ECDHidden))

            {

            aDbs.SetAttributeMask(ECDHidden);

            removeHiddenMask = ETrue;

            }

		}

	else

		{

		// this will give next valid record number

		newRecord->SetRecordId(KCDNewRecordRequest);		

		}

	// create and store record placeholder

	newRecord->StoreL(aDbs);

    if (removeHiddenMask)

        {

        aDbs.ClearAttributeMask(ECDHidden);

        }

	// check if inserted record has the same record id as previously deleted record

	TInt index = iDeletedRecords.Find(newRecord->RecordId());

	if(index >= 0)

		{

		iDeletedRecords.Remove(index);

		}

	// append inserted record

	User::LeaveIfError(recSet->iRecords.Append(newRecord));

	CleanupStack::Pop(newRecord);

	iCurrentRecord = newRecord;

	SortById();

	aId = newRecord->RecordId();

	}

TInt CCommDbTableExtension::CancelRecordChanges(CMDBSession& aDbs)

	{

	TInt err = KErrNone;

	if (!iRecordSetContainer)

		{

		return KErrNotFound;

		}

	TRAP(err,iCurrentRecord->LoadL(aDbs));

	if (err != KErrNone) 

		{

		// return to status prior to failure

		__FLOG_STATIC1(KLogComponent, KCommDbShim, _L("CCommDbTableExtension::CancelRecordChanges failed to Refresh the data, Err=%d"),err);

		return err;

		}

	if (iInsertedRecords.Count()) 

		{

		TInt index = FindValueInRecSet(iInsertedRecords[KFirstRecord]);

		if(index >= 0)

			{

			delete iRecordSetContainer->iRecords[index];

			iRecordSetContainer->iRecords.Remove(index);

			iRecordSetContainer->iRecords.Compress();

			// reuse index variable

			index = iRecordSetContainer->iRecords.Count();

			index ? iCurrentRecord = iRecordSetContainer->iRecords[index-1] : iCurrentRecord = NULL;

			}

		}

	ResetArrays(aDbs);

	return err;

	}

void CCommDbTableExtension::ResetArrays(CMDBSession& aSession) 

	{

	if(!aSession.IsInTransaction())

		{

		iInsertedRecords.Reset();

		iDeletedRecords.Reset();

		}

	// else they will be reseted on Commit or Rolback Transaction

	}

void CCommDbTableExtension::ResetAndDestroyL() 

	{

	GetRecordSetL()->iRecords.ResetAndDestroy();

	iCurrentRecord = NULL;

	}

void CCommDbTableExtension::DeleteCurrentRecordL(CMDBSession& aDbs, TBool aContainerOnly)

/**

Deletes the current record from commsdat and from queue.

Updates the value of record index.

*/

    {

    // check for validity of current record through GetCurrentRecord call

    CMDBRecordBase* currRec = GetCurrentRecordL();

    /* TODO: Add iShowHidden in conditions. This might not be necessary checking */

    /*if(iRecordIndex == 0) 

        {

        // it is not possible to delete template record

        User::Leave(KErrNotSupported);

        }*/

	if(!aContainerOnly)

		{

		if (currRec->IsSetAttribute(ECDProtectedWrite))