/*

* 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:  AdapterLog source

*

*/

// INCLUDE FILES

#include <s32file.h>

#include <s32stor.h>

#include <bautils.h>

#include <nsmlconstants.h>

#include<nsmlconstantdefs.h>

#include <nsmldsconstants.h>

#include "NSmlAdapterLog.h"

// STATIC CONSTANTS

const TInt CNSmlAdapterLog::KMaxPathLength;

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

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

// CNSmlAdapterLog::CNSmlAdapterLog

// C++ default constructor.

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

//

CNSmlAdapterLog::CNSmlAdapterLog()

    {

    }

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

// CNSmlAdapterLog::ConstructL

// Symbian 2nd phase constructor.

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

//

void CNSmlAdapterLog::ConstructL()

    {

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

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

    iPath = HBufC::NewL(CNSmlAdapterLog::KMaxPathLength);

    TPtr path = iPath->Des();

    User::LeaveIfError(iFsSession.SetSessionToPrivate(KNSmlAdapterLogDrive));

    User::LeaveIfError(iFsSession.SessionPath(path));

    BaflUtils::EnsurePathExistsL(iFsSession, *iPath);

    delete iPath;

    iPath = NULL;

    TParse name;

#ifdef SYMBIAN_SECURE_DBMS

	name.Set(KNSmlAdapterLogDbName(), NULL, NULL);

#else

    name.Set(KNSmlAdapterLogDbName(), KNSmlDatabasesNonSecurePath, NULL);

#endif

    TInt err(KErrNone);

    RProcess currentProcess;

    const TSecureId secureId = currentProcess.SecureId();

    currentProcess.Close();

    if ( secureId.iId == KNSmlDSHostRWServerSecureID.iId )

        {

        err = iDatabase.Open(iRdbSession,

                             name.FullName(), KNSmlDBMSSecureDSHostRWID);

        if ( err == KErrNotFound )

            {

            CreateDatabaseL(name.FullName());

            err = iDatabase.Open(iRdbSession,

                               name.FullName(), KNSmlDBMSSecureDSHostRWID);

            }

        }

    else if (secureId.iId == KNSmlDSHostNULLServerSecureID.iId)

        {

        err = iDatabase.Open(iRdbSession,

                             name.FullName(), KNSmlDBMSSecureDSHostNULLID);

        if ( err == KErrNotFound )

            {

            CreateDatabaseL(name.FullName());

            err = iDatabase.Open(iRdbSession, name.FullName(), 

                                 KNSmlDBMSSecureDSHostNULLID);

            }

        }

    else

        {

        User::Leave( KErrAccessDenied );

        }

    User::LeaveIfError(err);            

    User::LeaveIfError(iTable.Open(iDatabase, KNSmlTableAdapterLog));

    iColSet = iTable.ColSetL();

    }

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

// CNSmlAdapterLog::NewL

// Two-phased constructor.

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

//

EXPORT_C CNSmlAdapterLog* CNSmlAdapterLog::NewL()

    {

    CNSmlAdapterLog* self = CNSmlAdapterLog::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

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

// CNSmlAdapterLog::NewLC

// Two-phased constructor.

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

//

EXPORT_C CNSmlAdapterLog* CNSmlAdapterLog::NewLC()

    {

    CNSmlAdapterLog* self = new (ELeave) CNSmlAdapterLog;

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CNSmlAdapterLog::~CNSmlAdapterLog()

// Destructor

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

CNSmlAdapterLog::~CNSmlAdapterLog()

    {

    delete iPath;

    if (iDictionaryStore)

        {

        iDictionaryStore->Commit();

        delete iDictionaryStore;

        }

   	iView.Close();

    delete iColSet;

    iTable.Close();    

    iDatabase.Close();

    iFsSession.Close();

    iRdbSession.Close();

    }

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

// CNSmlAdapterLog::SetAdapterLogKeyL

// Sets the sync relationship key.

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

//

EXPORT_C void CNSmlAdapterLog::SetAdapterLogKeyL(

             const TInt aImplUid, const TDesC& aLocalDB, 

             const TDesC& aServerId, const TDesC& aRemoteDB)

    {

    HBufC* sql = HBufC::NewLC(KSqlGetAdapterLogRow().Length() + 5 + 

        aLocalDB.Length() + aServerId.Length() + aRemoteDB.Length());

    TPtr tmp = sql->Des();

    tmp.Format(KSqlGetAdapterLogRow, aImplUid, &aLocalDB, &aServerId,

        &aRemoteDB);

    iView.Close();

    User::LeaveIfError(iView.Prepare(iDatabase, TDbQuery(*sql),

                                     RDbView::/*TAccess::*/EUpdatable));

    if (iView.FirstL())

        {

        // existing row

        iView.GetL();

        iID = iView.ColInt(iColSet->ColNo(KNSmlAdapterLogId));

        }

    else

        {

        // new row

        iID = GenerateIdL();

        iDatabase.Begin();

        iView.InsertL();

        iView.SetColL(iColSet->ColNo(KNSmlAdapterLogId), iID);

        iView.SetColL(iColSet->ColNo(KNSmlAdapterLogImplementationUID), aImplUid);

        iView.SetColL(iColSet->ColNo(KNSmlAdapterLogLocalDatabase), aLocalDB);

        iView.SetColL(iColSet->ColNo(KNSmlAdapterLogServerId), aServerId);

        iView.SetColL(iColSet->ColNo(KNSmlAdapterLogRemoteDatabase), aRemoteDB);   

        iView.PutL();

        iDatabase.Commit();

        iDatabase.Compact();

        }

    CleanupStack::PopAndDestroy(sql);

    OpenDictionaryStoreL();

    }

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

// CNSmlAdapterLog::SetServerIdL

// Sets server id.

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

//    

EXPORT_C void CNSmlAdapterLog::SetServerIdL( TDesC& aOldServerId, TDesC& aNewValue )

	{

	HBufC* sql = HBufC::NewLC( KSqlGetAdapterLogRowFromServerId().Length() + aOldServerId.Length() );

	TPtr tmp = sql->Des();

    tmp.Format( KSqlGetAdapterLogRowFromServerId,  &aOldServerId );

	iView.Close();

	User::LeaveIfError( iView.Prepare( iDatabase, TDbQuery(*sql),

                                     RDbView::EUpdatable ) );

	iDatabase.Begin();

	if ( iView.FirstL() )

		{

		//existing row

		iView.GetL();

		iView.UpdateL();

		iView.SetColL( iColSet->ColNo( KNSmlAdapterLogServerId ), aNewValue );

		iView.PutL();

		iDatabase.Commit();

		iDatabase.Compact();

		}

	CleanupStack::PopAndDestroy( sql );

	}

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

// CNSmlAdapterLog::SyncTaskKey

// Returns the unique identifier for the synchronization relationship. The

// default value for the identifier (zero) is returned, if the adapter log key

// has not been set.

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

//

EXPORT_C TSmlSyncTaskKey CNSmlAdapterLog::SyncTaskKey() const

    {

    return static_cast<TSmlSyncTaskKey>(iID);    

    }

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

// CNSmlAdapterLog::OpenReadStreamLC

// Opens the dictionary stream associated with the given UID, leaving the 

// cleanup item on cleanup stack. The adapter log key has to be set before this

// method can be used. Method leaves, if association with a stream and the

// given uid does not exist in the store.

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

//

EXPORT_C void CNSmlAdapterLog::OpenReadStreamLC(RReadStream& aReadStream,

                                                TUid aStreamUid)

    {

    if (!IsStreamPresentL(aStreamUid))

        {

        User::Leave(KErrNotFound);

        }

    static_cast<RDictionaryReadStream&>(aReadStream).OpenLC(

        *iDictionaryStore, aStreamUid);

    }

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

// CNSmlAdapterLog::OpenWriteStreamLC

// Opens the dictionary stream associated with the given UID, leaving the

// cleanup item on cleanup stack. If no stream is associated with the UID, new

// stream is created with association to given UID. The adapter log key has to

// be set before this method can be used.

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

//

EXPORT_C void CNSmlAdapterLog::OpenWriteStreamLC(RWriteStream& aWriteStream,

                                                 TUid aStreamUid)

    {

    if (iID == NULL)

        {

        User::Leave(KErrNotFound);

        }

    static_cast<RDictionaryWriteStream&>(aWriteStream).AssignLC(

        *iDictionaryStore, aStreamUid);

    }

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

// CNSmlAdapterLog::IsStreamPresentL

// Checks if a stream associated with given UID is present in the opened

// dictionary store. The adapter log key has to be set before this

// method can be used.

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

//

EXPORT_C TBool CNSmlAdapterLog::IsStreamPresentL(TUid aStreamUid) const

    {

    if (iID == NULL)

        {

        User::Leave(KErrNotFound);

        }

    return iDictionaryStore->IsPresentL(aStreamUid);

    }

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

// CNSmlAdapterLog::CreateDatabaseL

// Creates new database with AdapterLog table in the specified file.

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

//

void CNSmlAdapterLog::CreateDatabaseL(const TDesC& aFullName)

    {

	_LIT(KCreateAdapterLogTable, "CREATE TABLE AdapterLog (Id \

	INTEGER NOT NULL, ImplementationUID INTEGER NOT NULL, LocalDatabase CHAR(%d) \

	NOT NULL, ServerId CHAR(%d), RemoteDatabase CHAR(%d) NOT NULL)");

    HBufC* createAdapterLogTable = 

        HBufC::NewLC(KCreateAdapterLogTable().Length() + 20);

    TPtr AdapterLogTablePtr = createAdapterLogTable->Des();

    AdapterLogTablePtr.Format(KCreateAdapterLogTable, KNSmlMaxDataLength,

                              KNSmlMaxServerIdLength, KNSmlMaxRemoteNameLength);

    RProcess currentProcess;

    const TSecureId secureId = currentProcess.SecureId();

    currentProcess.Close();

    if ( secureId.iId == KNSmlDSHostRWServerSecureID.iId )

        {

        User::LeaveIfError(iDatabase.Create(iRdbSession,

                                            aFullName,

                                            KNSmlDBMSSecureDSHostRWID));

        }

    else if (secureId.iId == KNSmlDSHostNULLServerSecureID.iId)

        {

        User::LeaveIfError(iDatabase.Create(iRdbSession,

                                            aFullName,

                                            KNSmlDBMSSecureDSHostNULLID));

        }

    else

        {

        User::Leave( KErrAccessDenied );

        }

    iDatabase.Begin();

    iDatabase.Execute(*createAdapterLogTable);                                          

    iDatabase.Commit();

	iDatabase.Compact();

	iDatabase.Close();

	CleanupStack::PopAndDestroy(createAdapterLogTable);

    }

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

// CNSmlAdapterLog::GenerateIdL

// Generates a unique identifier for the table by searching the adapter log ID

// with highest value and increments it.

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

//

TInt CNSmlAdapterLog::GenerateIdL()

    {

    TInt highestKey(0);

    if (iTable.LastL())

        {

        TInt currentKey(0);

        do

            {

            iTable.GetL();

            currentKey = iTable.ColInt(iColSet->ColNo(KNSmlAdapterLogId));

            if (highestKey < currentKey)

                {

                highestKey = currentKey;

                }

            }

        while (iTable.PreviousL());

        }

    return highestKey + 1;    

    }

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

// CNSmlAdapterLog::OpenDictionaryStoreL

// Opens the dictionary file store associated with the adapter log ID.

// If dictionary store has already been opened, method establishes new commit

// point for opened store and closes the store before opening another.

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

//

void CNSmlAdapterLog::OpenDictionaryStoreL()

    {

    if (iDictionaryStore)

        {

        iDictionaryStore->CommitL();

        delete iDictionaryStore;

        iDictionaryStore = NULL;

        }

    HBufC* storeName = HBufC::NewLC(KNSmlAdapterLogStore().Length() + 10);

    TPtr tmp = storeName->Des();

    tmp.Format(KNSmlAdapterLogStore(), iID);

    iPath = HBufC::NewL(CNSmlAdapterLog::KMaxPathLength);

    TPtr path = iPath->Des();

    TParse file;

    User::LeaveIfError(file.Set(*storeName, iPath, NULL));

    iDictionaryStore = CDictionaryFileStore::OpenL(iFsSession, file.FullName(),

                                                   TUid::Uid(iID));

    CleanupStack::PopAndDestroy(storeName);

    }

//  End of File