/*

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

*

*/

#include "activitystorage.h"

#include "activityqueries.h"

#include <bautils.h>

#include <s32mem.h>

_LIT(KDbName, "activity.db");

_LIT(KDbDrive, "c:");

const TInt KMaxPathLength = 256;

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

//

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

//

CActivityStorage::CActivityStorage(RFs& session)

:

mFsSession(session)

{

    // No implementation required

}

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

//

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

//

CActivityStorage::~CActivityStorage()

{

}

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

//

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

//

CActivityStorage* CActivityStorage::NewL(RFs& session)

{

    CActivityStorage* self = new (ELeave) CActivityStorage(session);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(); // self;

    return self;

}

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

//

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

//

void CActivityStorage::ConstructL()

{

    RBuf path;

    CleanupClosePushL( path );

    path.CreateL(KMaxPathLength);

    User::LeaveIfError(mFsSession.PrivatePath(path ));

    path.Append(KDbName);

    path.Insert(0, KDbDrive);

    BaflUtils::EnsurePathExistsL(mFsSession, path);

    BaflUtils::FileExists(mFsSession, path) ? OpenDbL(path) : CreateDbL(path);

    CleanupStack::PopAndDestroy(&path);

}

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

//

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

//

void CActivityStorage::CreateDbL(const TDesC& databaseFile)

{

    mFileStore = CPermanentFileStore::ReplaceL(mFsSession, 

                                               databaseFile, 

                                               EFileRead|EFileWrite);

    mFileStore->SetTypeL(mFileStore->Layout());// Set file store type

    TStreamId id = mActDb.CreateL(mFileStore);// Create stream object

    mFileStore->SetRootL(id);// Keep database id as root of store

    mFileStore->CommitL();// Complete creation by commiting

    CreateTableL();

}

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

//

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

//

void CActivityStorage::OpenDbL(const TDesC& databaseFile)

{

    mFileStore = CPermanentFileStore::OpenL(mFsSession, 

                                            databaseFile, 

                                            EFileRead|EFileWrite);

    mFileStore->SetTypeL(mFileStore->Layout()); /* Set file store type*/

    mActDb.OpenL(mFileStore,mFileStore->Root());

    CDbTableNames* tables = mActDb.TableNamesL();

    CleanupStack::PushL(tables);

    if (0 == tables->Count()) {

        CreateTableL();

    }

    CleanupStack::PopAndDestroy(tables);

}

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

//

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

//

void CActivityStorage::CreateTableL()

{

   // Add the columns to column set

   CDbColSet* actColSet = CDbColSet::NewLC();

   TDbCol appName(KApplicationColumnName, EDbColInt64);// Using default length

   appName.iAttributes = TDbCol::ENotNull;

   actColSet->AddL(appName);

   TDbCol actName(KActivityColumnName, EDbColText8);// Using default length

   actName.iAttributes = TDbCol::ENotNull;

   actColSet->AddL(actName);

   actColSet->AddL(TDbCol(KDataColumnName, EDbColLongText8));// Stream Data

   // Add the columns to index definition

   CDbKey* primaryKey = CDbKey::NewLC();

   primaryKey->AddL(TDbKeyCol(KApplicationColumnName));

   primaryKey->AddL(TDbKeyCol(KActivityColumnName));

   primaryKey->MakePrimary();

   // Create the table

   /*User::LeaveIfError(mActDb.CreateTable(KActivityTableName, 

                                         *actColSet, 

                                         *primaryKey));*/

   User::LeaveIfError(mActDb.CreateTable(KActivityTableName, 

                                            *actColSet));

   /*User::LeaveIfError(mActDb.CreateIndex(KActivityIndexName, 

                                         KActivityTableName, 

                                         *primaryKey));*/

   CleanupStack::PopAndDestroy(primaryKey);

   CleanupStack::PopAndDestroy(actColSet);

}

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

//

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

//

void CActivityStorage::AddActivityL(TInt appId, 

                                    const TDesC8& actId, 

                                    const TDesC8& data)

{

    //verify if row already exists

    RDbView view;

    CleanupClosePushL(view);

    TRAPD( errNo, GetActivityForUpdateL(view, appId, actId));

    if (KErrNone == errNo) {

        User::Leave(KErrAlreadyExists);

    }

    CleanupStack::PopAndDestroy(&view);

    //write table

    RDbTable table;

    CleanupClosePushL(table);

    User::LeaveIfError(table.Open(mActDb, KActivityTableName, table.EUpdatable));

    CDbColSet *row = table.ColSetL();

    CleanupStack::PushL(row);

    table.InsertL();

    table.SetColL(row->ColNo(KApplicationColumnName), TInt64(appId));

    table.SetColL(row->ColNo(KActivityColumnName), actId);

    //write blob data

    RDbColWriteStream stream;

    CleanupClosePushL(stream);

    stream.OpenL(table, row->ColNo(KDataColumnName));

    stream.WriteL(data);

    CleanupStack::PopAndDestroy(&stream);

    table.PutL();

    CleanupStack::PopAndDestroy(row);

    CleanupStack::PopAndDestroy(&table);

}

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

//

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

//

void CActivityStorage::UpdateActivityL(TInt appId, 

                                       const TDesC8& actId, 

                                       const TDesC8& data)

{

    RDbView view;

    CleanupClosePushL(view);

    GetActivityForUpdateL(view, appId, actId);

    view.UpdateL();

    CDbColSet* colSet = view.ColSetL();

    CleanupStack::PushL(colSet);

    RDbColWriteStream writeStream;

    CleanupClosePushL(writeStream);

    writeStream.OpenL(view, colSet->ColNo(KDataColumnName));

    writeStream.WriteL(data);

    CleanupStack::PopAndDestroy(&writeStream);

    view.PutL();

    CleanupStack::PopAndDestroy(colSet);

    CleanupStack::PopAndDestroy(&view);

}

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

//

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

//

void CActivityStorage::DeleteActivityL(TInt appId,const TDesC8& actId) 

{

    HBufC *query(DeleteRowLC(appId, actId));

    User::LeaveIfError(mActDb.Execute(*query));

    CleanupStack::PopAndDestroy(query);

}

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

//

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

//

void CActivityStorage::DeleteActivitiesL(TInt appId)

{

    HBufC *query(DeleteRowsLC(appId));

    User::LeaveIfError(mActDb.Execute(*query));

    CleanupStack::PopAndDestroy(query);

}

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

//

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

//

void CActivityStorage::ActivitiesL(RBuf8 &dst)

{

    ActivitiesL(dst, KSelectRows() );

}

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

//

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

//

void CActivityStorage::ActivitiesL(RBuf8 &dst,TInt appId)

{

    HBufC *query(SelectRowsLC(appId));

    ActivitiesL(dst, *query);

    CleanupStack::PopAndDestroy(query);

}

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

//

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

//

HBufC* CActivityStorage::SelectRowLC(TInt appId, const TDesC8& actId) const 

{

    return BuildQueryLC(KSelectRow(),appId, actId);

}

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

//

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

//

HBufC* CActivityStorage::SelectRowsLC(TInt appId) const

{

    return BuildQueryLC(KSelectAppRows(), appId, KNullDesC8);

}

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

//

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

//

HBufC* CActivityStorage::DeleteRowLC(TInt appId, const TDesC8& actId) const

{

    return BuildQueryLC(KDeleteRow(),appId, actId);

}

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

//

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

//

HBufC* CActivityStorage::DeleteRowsLC(TInt appId) const

{

    return BuildQueryLC(KDeleteRows(),appId, KNullDesC8);

}

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

//

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

//

HBufC* CActivityStorage::BuildQueryLC(const TDesC& format, 

                                      TInt appId, 

                                      const TDesC8& actId) const

{

    TBuf<16> appName;

    appName.AppendNum(appId);

    RBuf actName;

    CleanupClosePushL(actName);

    actName.CreateL(actId.Length());

    actName.Copy(actId);

    HBufC* query = HBufC::NewL(format.Length() + 

                               appName.Length() + 

                               actName.Length() );

    query->Des().AppendFormat(format, &appName, &actName);

    CleanupStack::PopAndDestroy(&actName);

    CleanupStack::PushL(query);

    return query;

}

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

//

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

//

TInt CActivityStorage::DataSizeL(RDbRowSet& data)const

{

    TInt dataSize(sizeof(TInt));

    CDbColSet* row = data.ColSetL();

    CleanupStack::PushL(row);

    const TInt dataOffset(row->ColNo(KDataColumnName));

    for (data.FirstL(); data.AtRow(); data.NextL()) {

        data.GetL();

        dataSize += (sizeof(TInt) + 

                     data.ColLength(dataOffset));

    }

    CleanupStack::PopAndDestroy(row);

    return dataSize;

}

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

//

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

//

void CActivityStorage::ExternalizeL(TDes8& dst, RDbRowSet& src)const

{

    RDesWriteStream dstStream(dst);

    CleanupClosePushL(dstStream);

    dstStream.WriteInt32L(src.CountL());

    RBuf8 data;

    CleanupClosePushL(data);

    CDbColSet* row = src.ColSetL();

    CleanupStack::PushL(row);

    const TInt dataOffset(row->ColNo(KDataColumnName));

    RDbColReadStream srcStream;

    CleanupClosePushL(srcStream);

    for (src.FirstL(); src.AtRow(); src.NextL()) {

        src.GetL();

        if (data.MaxLength() < src.ColLength(dataOffset)) {

            data.ReAllocL(src.ColLength(dataOffset));

        }

        data.SetLength(0);

        srcStream.OpenL(src,dataOffset);

        srcStream.ReadL(data, src.ColLength(dataOffset));

        srcStream.Close();

        dstStream.WriteInt32L(src.ColLength(dataOffset));

        if (0 < src.ColLength(dataOffset)) {

            dstStream.WriteL(data, src.ColLength(dataOffset));

        }

    }

    CleanupStack::PopAndDestroy(&srcStream);

    CleanupStack::PopAndDestroy(row);

    CleanupStack::PopAndDestroy(&data);

    CleanupStack::PopAndDestroy(&dstStream);

}

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

//

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

//

void CActivityStorage::ActivitiesL(RBuf8& dst, const TDesC& query)

{

    RDbView view;// Create a view on the database

    CleanupClosePushL(view);

    User::LeaveIfError(view.Prepare(mActDb, TDbQuery(query), view.EReadOnly));

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

    const TInt dataSize(DataSizeL(view));

    if(dst.MaxLength() < dataSize) {

        dst.ReAllocL(dataSize);

    }

    ExternalizeL(dst, view);

    CleanupStack::PopAndDestroy(&view);

}

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

//

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

//

void CActivityStorage::GetActivityForUpdateL(RDbView& view, TInt appId, const TDesC8& actId)

{

    HBufC* query(SelectRowLC(appId, actId));

    User::LeaveIfError(view.Prepare(mActDb, TDbQuery(*query), view.EUpdatable));

    CleanupStack::PopAndDestroy(query);

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

    if (!view.FirstL()) {

        User::Leave(KErrNotFound);

    }

}