/*

* Copyright (c) 2005 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: 

*   ?description_line

*

*/

// INCLUDE FILES

#include <f32file.h>

#include "FT_DatabaseUtility.h"

#include <D32DBMS.H>

#include <EPos_Landmarks.h>

// CONSTANTS

// ============================ MEMBER FUNCTIONS ===============================

// Code below taken from EPos_PosLmDatabaseManager.cpp

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

// FTDatabaseUtility::CreateDatabaseL

// 

// (other items were commented in a header).

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

//

void FTDatabaseUtility::CreateDatabaseL(const TDesC& aDbPath, TBool aReplaceDatabase, TBool aWrongId, TBool aCreateInvalidIndex)

    {

    RDbs dbSession;

    CleanupClosePushL(dbSession);

    User::LeaveIfError(dbSession.Connect());

    TPtrC dbPath(aDbPath);

    RDbNamedDatabase db;

    CleanupClosePushL(db);

    TUid KPosSecureUidWrongId = { 0x10204058 };

    _LIT(KWrongIdString, "secure[10204058]");

    if (aReplaceDatabase)

        {

        TInt err =KErrNone;

        if (!aWrongId) err = dbSession.DeleteDatabase(dbPath, KPosLmDbSecureUid);

        else err = dbSession.DeleteDatabase(dbPath, KPosSecureUidWrongId);

        if (err == KErrNone || err == KErrNotFound)

            {

            if (!aWrongId) User::LeaveIfError(db.Create(dbSession, dbPath, KPosLmDbSecureFormat));

            else User::LeaveIfError(db.Create(dbSession, dbPath, KWrongIdString));

            }

        else

            {

            User::Leave(err);

            }

        }

    else

        {

        if (!aWrongId) 

        {

		User::LeaveIfError(db.Create(dbSession, dbPath, KPosLmDbSecureFormat));

        }

        else User::LeaveIfError(db.Create(dbSession, dbPath, KWrongIdString));

        }

    CreateTablesL(db, aCreateInvalidIndex);

    CreateIndexesL(db);

    SetCounterToOneL(db, KPosLmLandmarkTable);

    SetCounterToOneL(db, KPosLmCategoryTable);

    // The settings table is created last so that a database can be validated 

    // when opening it (there will be a check for language there which is a 

    // part of the settings table).

    CreateSettingsTableL(db);

    CleanupStack::PopAndDestroy(2, &dbSession); // &db

    }

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

// FTDatabaseUtility::CreateTablesL

// 

// (other items were commented in a header).

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

//

void FTDatabaseUtility::CreateTablesL(

    RDbNamedDatabase& aDb, TBool aCreateInvalidIndex)

    {

    CreateLandmarkTableL(aDb, aCreateInvalidIndex);

    CreateLandmarkFieldTableL(aDb);

    CreateCategoryTableL(aDb, aCreateInvalidIndex);

    CreateLmCategoryTableL(aDb);

    CreateIconTableL(aDb);

    // Do not create settings table here. This is created in the end so that the

    // database can be validated when opening it.

    }

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

// FTDatabaseUtility::CreateLandmarkTableL

// 

// (other items were commented in a header).

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

//

void FTDatabaseUtility::CreateLandmarkTableL(

    RDbNamedDatabase& aDb, TBool aCreateInvalidIndex)

    {

    CDbColSet* columns = CDbColSet::NewLC();

    TDbCol col(KPosLmLandmarkIdCol, EDbColUint32);

    col.iAttributes = col.EAutoIncrement;

    columns->AddL(col);

    columns->AddL(TDbCol(KPosLmLatitudeCol, EDbColReal64));

    columns->AddL(TDbCol(KPosLmLongitudeCol, EDbColReal64));

    columns->AddL(TDbCol(KPosLmAltitudeCol, EDbColReal32));

    // Dont create the following tables when creating invalid table

    if (!aCreateInvalidIndex)

    	{

    	columns->AddL(TDbCol(KPosLmHorizAccCol, EDbColReal32));

        columns->AddL(TDbCol(KPosLmVertAccCol, EDbColReal32));

        columns->AddL(TDbCol(KPosLmCoverageRadiusCol, EDbColReal32));

        columns->AddL(TDbCol(KPosLmIconIdCol, EDbColUint32));

		columns->AddL(TDbCol(KPosLmIconPicNrCol, EDbColInt32));

        columns->AddL(TDbCol(KPosLmMaskPicNrCol, EDbColInt32));

	    columns->AddL(TDbCol(KPosLmNameCol, EDbColLongText, 

        	KPosLmMaxTextFieldLength));

    	}

    columns->AddL(TDbCol(KPosLmNDescCol, EDbColLongText, 

        	KPosLmMaxDescriptionLength));

    User::LeaveIfError(aDb.CreateTable(KPosLmLandmarkTable, *columns));

    CleanupStack::PopAndDestroy(columns);

    }

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

// FTDatabaseUtility::CreateLandmarkFieldTableL

// 

// (other items were commented in a header).

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

//

void FTDatabaseUtility::CreateLandmarkFieldTableL(

    RDbNamedDatabase& aDb)

    {

    CDbColSet* columns = CDbColSet::NewLC();

    TDbCol col(KPosLmLandmarkIdCol, EDbColUint32);

    col.iAttributes = col.ENotNull;

    columns->AddL(TDbCol(col));

    TDbCol col2(KPosLmFieldTypeCol, EDbColUint16);

    col2.iAttributes = col2.ENotNull;

    columns->AddL(col2);

    columns->AddL(TDbCol(KPosLmFieldStringCol, EDbColLongText,

        KPosLmMaxTextFieldLength));

    User::LeaveIfError(aDb.CreateTable(KPosLmLandmarkFieldTable, *columns));

    CleanupStack::PopAndDestroy(columns);

    }

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

// FTDatabaseUtility::CreateCategoryTableL

// 

// (other items were commented in a header).

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

//

void FTDatabaseUtility::CreateCategoryTableL(

    RDbNamedDatabase& aDb, TBool aCreateInvalidIndex)

    {

    CDbColSet* columns = CDbColSet::NewLC();

    TDbCol col(KPosLmCategoryIdCol, EDbColUint32);

    col.iAttributes = col.EAutoIncrement;

    columns->AddL(col);

    columns->AddL(TDbCol(KPosLmGlobalCategoryIdCol, EDbColUint16));

    columns->AddL(TDbCol(KPosLmIconIdCol, EDbColUint32));

    columns->AddL(TDbCol(KPosLmIconPicNrCol, EDbColInt32));

    columns->AddL(TDbCol(KPosLmMaskPicNrCol, EDbColInt32));

    columns->AddL(TDbCol(KPosLmCategoryNameCol, EDbColText, 

        KPosLmMaxCategoryNameLength));

    // Dont create the following tables when creating invalid table

    if (!aCreateInvalidIndex)

    	{

        columns->AddL(TDbCol(KPosLmCategoryNameModifiedCol, EDbColBit));

        }

    User::LeaveIfError(aDb.CreateTable(KPosLmCategoryTable, *columns));

    CleanupStack::PopAndDestroy(columns);

    }

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

// FTDatabaseUtility::CreateLmCategoryTableL

// 

// (other items were commented in a header).

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

//

void FTDatabaseUtility::CreateLmCategoryTableL(

    RDbNamedDatabase& aDb)

    {

    CDbColSet* columns = CDbColSet::NewLC();

    TDbCol col(KPosLmLandmarkIdCol, EDbColUint32);

    col.iAttributes = col.ENotNull;

    columns->AddL(col);

    TDbCol col2(KPosLmCategoryIdCol, EDbColUint32);

    col2.iAttributes = col2.ENotNull;

    columns->AddL(col2);

    User::LeaveIfError(aDb.CreateTable(KPosLmLandmarkCategoryTable, *columns));

    CleanupStack::PopAndDestroy(columns);

    }

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

// FTDatabaseUtility::CreateIconTableL

// 

// (other items were commented in a header).

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

//

void FTDatabaseUtility::CreateIconTableL(

    RDbNamedDatabase& aDb)

    {

    CDbColSet* columns = CDbColSet::NewLC();

    TDbCol col(KPosLmIconIdCol, EDbColUint32);

    col.iAttributes = col.EAutoIncrement;

    columns->AddL(col);

    columns->AddL(TDbCol(KPosLmIconPathCol, EDbColLongText, KMaxFileName));

    User::LeaveIfError(aDb.CreateTable(KPosLmIconTable, *columns));

    CleanupStack::PopAndDestroy(columns);

    }

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

// FTDatabaseUtility::CreateSettingsTableL

// 

// (other items were commented in a header).

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

//

void FTDatabaseUtility::CreateSettingsTableL(

    RDbNamedDatabase& aDb)

    {

    CDbColSet* columns = CDbColSet::NewLC();

    columns->AddL(TDbCol(KPosLmLanguageCol, EDbColInt32));

    columns->AddL(TDbCol(KPosLmInitFlagCol, EDbColInt32));

    User::LeaveIfError(aDb.CreateTable(KPosLmSettingsTable, *columns));

    CleanupStack::PopAndDestroy(columns);

    }

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

// FTDatabaseUtility::CreateIndexesL

// 

// (other items were commented in a header).

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

//

void FTDatabaseUtility::CreateIndexesL(

    RDbNamedDatabase& aDb)

    {

    CreateIndexL(aDb, KPosLmLandmarkIdIndex, KPosLmLandmarkTable, 

        KPosLmLandmarkIdCol, ETrue);

    CreateIndexL(aDb, KPosLmCategoryIdIndex, KPosLmCategoryTable, 

        KPosLmCategoryIdCol, ETrue);

    CreateIndexL(aDb, KPosLmGlobalCategoryIdIndex, KPosLmCategoryTable, 

        KPosLmGlobalCategoryIdCol, EFalse);

    CreateIndexL(aDb, KPosLmCategoryNameIndex, KPosLmCategoryTable, 

        KPosLmCategoryNameCol, ETrue);

    CreateIndexL(aDb, KPosLmIconIdIndex, KPosLmIconTable, 

        KPosLmIconIdCol, ETrue);

    }

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

// FTDatabaseUtility::CreateIndexL

// 

// (other items were commented in a header).

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

//

void FTDatabaseUtility::CreateIndexL(

    RDbNamedDatabase& aDb,

    const TDesC& aIndex, 

    const TDesC& aTable,

    const TDesC& aColumn,

    TBool aUnique)

    {

    CDbKey* keys = CDbKey::NewLC();

    keys->AddL(TDbKeyCol(aColumn));

    if (aUnique)

        {

        keys->MakeUnique();

        }

    User::LeaveIfError(aDb.CreateIndex(aIndex, aTable, *keys));

    CleanupStack::PopAndDestroy(keys);

    }

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

// FTDatabaseUtility::SetCounterToOneL

// 

// (other items were commented in a header).

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

//

void FTDatabaseUtility::SetCounterToOneL(

    RDbNamedDatabase& aDb, 

    const TDesC& aTable)

    {

    HBufC* sql = HBufC::NewLC(KPosLmSqlStatementMaxLen);

    sql->Des().Format(KPosLmSqlSelect, &KPosLmSqlAll, &aTable);

    RDbView view;

    CleanupClosePushL(view);

    User::LeaveIfError(view.Prepare(aDb, TDbQuery(*sql), 

        TDbWindow::EUnlimited));

    view.InsertL();

    view.PutL();

    if (!view.FirstL())

        {

        User::Leave(KErrGeneral);

        }

    view.DeleteL();

    CleanupStack::PopAndDestroy(2, sql); //&view

    }

//  End of File