/*

* Copyright (c) 2010 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:  Utility class for creating and accessing the mde and Cpix Sync Table 

*

*/

#include "cpixmdedbmanager.h"

#include <harvesterserverlogger.h>

#include <s32strm.h> //to support RDbColReadStream::ReadL

#include <bautils.h>

#include "mdsitementity.h"

//database name

_LIT(KDriveC, "c:");

_LIT(KDBNAME, "_Sync.db");

_LIT(KMDECPIXSYNCTable,"MdeCpixSync");

_LIT(KObjectId, "ObjectId");

_LIT(KUri, "Uri");

_LIT(KDrive, "Drive");

_LIT(KMdeCpixSyncDbSqlInsert, "SELECT * FROM MdeCpixSync");

_LIT(KMdeCpixSyncDbSqlCheckExist, "SELECT * FROM MdeCpixSync WHERE ObjectId=%d");

//Not used. Can be deleted.

//_LIT(KMdeCpixSyncDbSqlDelete, "DELETE FROM MdeCpixSync WHERE ObjectId="); //39 chars

const TInt KMdeCpixSyncDbSqlDeleteSize(100); // %d costs 10 chars in max

_LIT(KUIDSTRINGHEX,"%x");

enum TNotepadColumnType

    {

    EKey = 1, // this must be 1 (DBMS/SQL restriction) mapped to ObjectID of MDS

    EUri,

    EDrive

    };

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

// CCPixIndexerUtils::NewL()

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

//

CCPIXMDEDbManager* CCPIXMDEDbManager::NewL(const TUid& aPluginImplUid)

    {

    CCPIXMDEDbManager* self = CCPIXMDEDbManager::NewLC(aPluginImplUid);

    CleanupStack::Pop(self);

    return self;

    }

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

// CCPIXMDEDbManager::NewLC()

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

//

CCPIXMDEDbManager* CCPIXMDEDbManager::NewLC(const TUid& aPluginImplUid)

    {

    CCPIXMDEDbManager* self = new (ELeave) CCPIXMDEDbManager();

    CleanupStack::PushL(self);

    self->ConstructL(aPluginImplUid);

    return self;

    }

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

// CCPIXMDEDbManager::~CCPIXMDEDbManager()

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

//

CCPIXMDEDbManager::~CCPIXMDEDbManager()

    {

    if(iOpened)

        {    

        iDatabase.Close();        

        }

    iFs.Close();

    }

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

// CCPixIndexerUtils::CCPixIndexerUtils()

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

//

CCPIXMDEDbManager::CCPIXMDEDbManager()

    {    

    }

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

// CCPixIndexerUtils::ConstructL()

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

//

void CCPIXMDEDbManager::ConstructL(const TUid& aPluginImplUid)

    {

    CPIXLOGSTRING("START CCPIXMDEDbManager::ConstructL : Enter");

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

    //Secure database needes policy file for every database and it is comparitively

    //lacks in performance from non secure database so we can use non secure

    //Create the database filename.

    HBufC* dataFile = HBufC::NewLC( KMaxFileName );    

    TBuf <10> aUidString;

    aUidString.Format(KUIDSTRINGHEX, aPluginImplUid);

    TFileName  privatePath;

    iFs.CreatePrivatePath(EDriveC);

    iFs.PrivatePath(privatePath);//data caged path of loading process

    dataFile->Des().Copy(KDriveC);

    dataFile->Des().Append(privatePath);//data caged path of Plugin        

    dataFile->Des().Append( aUidString );

    dataFile->Des().Append( KDBNAME );

    //Open the database

    TInt err(iDatabase.Open(iFs,*dataFile));

    switch (err)

         {

         case KErrNone:

             {

             iOpened = ETrue;            

             }

             break;

         case KErrNotFound:

             {

             //create the database and register for notifier

             TRAP( err , CreateMdeCPIXSyncDBL(*dataFile));

             if(err == KErrNone)

                 {

                 iOpened = ETrue;

                 }

             }

             break;

         default:            

             CPIXLOGSTRING("CNotesPlugin::ConstructL : Error in Database Open");

             break;

         }    

     CleanupStack::PopAndDestroy( dataFile );  

     CPIXLOGSTRING("END CCPIXMDEDbManager::ConstructL : Enter");

    }

void CCPIXMDEDbManager::CreateMdeCPIXSyncDBL(const TDesC& aDatabaseFile)

    {

    CPIXLOGSTRING("START CCPIXMDEDbManager::CreateMdeCPIXSyncDBL");

    iDatabase.Close();

    //Create the database filename.

    //create the database

    User::LeaveIfError(iDatabase.Create(iFs,aDatabaseFile));

    CDbColSet* columns = CreateColumnSetLC();//creates the columns and push to cleanupstack

    User::LeaveIfError( iDatabase.CreateTable( KMDECPIXSYNCTable , *columns ) );

    //clean up of variables (columns and dataFile)

    CleanupStack::PopAndDestroy( 1 ); //columns    

    CPIXLOGSTRING("END CCPixIndexerUtils::MountAllAvailableDriveL");

    }

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

// CNotesPlugin::CreateColSetLC

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

//

CDbColSet* CCPIXMDEDbManager::CreateColumnSetLC()

    {

    CPIXLOGSTRING("CCPIXMDEDbManager::CreateColSetLC: Entered");

    CDbColSet* columns = CDbColSet::NewLC();

    //Add Key column

    TDbCol col( KObjectId , EDbColInt32 );

    col.iAttributes = TDbCol::ENotNull;

    columns->AddL( col );

    col.iName = KUri;

    col.iType = EDbColLongText;

    col.iAttributes = TDbCol::ENotNull;

    columns->AddL(col);

    col.iName = KDrive;

    col.iType = EDbColInt32;

    col.iAttributes = TDbCol::ENotNull;

    columns->AddL(col);

    return columns; // columns stays on CleanupStack

    }

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

// CCPIXMDEDbManager::AddL

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

//

TCPIXMDEDBAPIReturnType CCPIXMDEDbManager::AddL(const TUint& aObjId,CMDSEntity& aMdsItem)

    {

    CPIXLOGSTRING("START CCPIXMDEDbManager::AddL");

    TCPIXMDEDBAPIReturnType retVal = EOperationUndefined;

    // Database is not openend

    // return Not ready

    if(!iOpened)

     {

     User::Leave(KErrNotReady);

     }

    iDatabase.Begin();    

    RDbView dbView;

    CleanupClosePushL(dbView);

    TBuf<KMdeCpixSyncDbSqlDeleteSize> sql;

    sql.Copy(KMdeCpixSyncDbSqlInsert);

    TInt err =  dbView.Prepare(iDatabase, TDbQuery(sql));

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

    //Getthe pointer to the Content recieved as part of the Command

    if(KErrNone == err) 

     {       

     dbView.InsertL();

     dbView.SetColL(EKey,aObjId);

     dbView.SetColL(EDrive, aMdsItem.DriveNumber());

     dbView.SetColL(EUri,aMdsItem.Uri());

     //Inserts the row       

     dbView.PutL();

     CPIXLOGSTRING("CCPIXMDEDbManager::AddL PutL");          

     retVal = EOperationSuccess;         

     }

    CleanupStack::PopAndDestroy(&dbView); // dbView

    if(retVal == EOperationSuccess)

        {

        iDatabase.Commit();

        iDatabase.Compact();

        }

    else

        {

        iDatabase.Rollback();

        }

    User::LeaveIfError(err);

    CPIXLOGSTRING("END CCPIXMDEDbManager::AddL");

    return retVal;

    }

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

// CCPIXMDEDbManager::UpdateL

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

//

TCPIXMDEDBAPIReturnType CCPIXMDEDbManager::UpdateL(const TUint& aObjId,CMDSEntity& aMdsItem)

    {

    CPIXLOGSTRING("START CCPIXMDEDbManager::UpdateL");

    TCPIXMDEDBAPIReturnType retVal = EOperationUndefined;

    // Database is not openend return Not ready

    if(!iOpened)

     {

     User::Leave(KErrNotReady);

     }

    iDatabase.Begin();

    RDbView dbView;

    CleanupClosePushL(dbView);

    TBuf<KMdeCpixSyncDbSqlDeleteSize> sql;

    sql.Format(KMdeCpixSyncDbSqlCheckExist,aObjId);

    User::LeaveIfError(dbView.Prepare(iDatabase, TDbQuery(sql)));

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

    if(dbView.AtRow())

        {

        dbView.UpdateL();

        dbView.SetColL(EKey,aObjId);

        dbView.SetColL(EDrive, aMdsItem.DriveNumber());

        dbView.SetColL(EUri,aMdsItem.Uri());

        //Update record 

        dbView.PutL();

        retVal = EOperationSuccess;

        }

    CleanupStack::PopAndDestroy(&dbView); // dbView

    if(retVal == EOperationSuccess)

        {

        iDatabase.Commit();

        iDatabase.Compact();

        }

    else

        {

        iDatabase.Rollback();

        }

    CPIXLOGSTRING("END CCPIXMDEDbManager::UpdateL");

    return retVal;

    }

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

// CNotesPlugin::RemoveL

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

//

TCPIXMDEDBAPIReturnType CCPIXMDEDbManager::RemoveL(const TUint& aObjId)

    {

    CPIXLOGSTRING("START CCPIXMDEDbManager::RemoveL");

    TCPIXMDEDBAPIReturnType retVal = EOperationUndefined;

    //If the database was not opened.

    // return Not ready

    if(!iOpened)

        {

        User::Leave(KErrNotReady);

        }

    TBuf<KMdeCpixSyncDbSqlDeleteSize> sql;

    sql.Format(KMdeCpixSyncDbSqlCheckExist,aObjId);

    iDatabase.Begin();

    //Prepare the view

    RDbView dbView;

    CleanupClosePushL(dbView);

    User::LeaveIfError(dbView.Prepare(iDatabase, TDbQuery(sql)));

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

    //Get the note property from the database for the given key.

    TBool isAtRow(dbView.FirstL());

    if ( isAtRow )

        {

        dbView.DeleteL();

        retVal = EOperationSuccess;

        CPIXLOGSTRING("CCPIXMDEDbManager::RemoveL Successful!");

        }

    else

        {

        //If the specified key was not found.

        retVal= EOperationFailure;

        }

    CleanupStack::PopAndDestroy(&dbView); // dbView

    if(EOperationSuccess == retVal)

        {

        iDatabase.Commit();

        iDatabase.Compact();

        }

    else

        {

        iDatabase.Rollback();

        }

    CPIXLOGSTRING("END CCPIXMDEDbManager::RemoveL");

    return retVal; 

    }

TBool CCPIXMDEDbManager::IsAlreadyExistL(const TUint& aObjectId)

    {

    CPIXLOGSTRING("START CCPIXMDEDbManager::IsAlreadyExistL");

    TBool retVal(EFalse);

    //If the database was not opened.

    // return Not ready

    if(!iOpened)

        {

        User::Leave(KErrNotReady);

        }

    TBuf<KMdeCpixSyncDbSqlDeleteSize> sql;

    sql.Format(KMdeCpixSyncDbSqlCheckExist,aObjectId);

    //Prepare the view

    RDbView dbView;

    CleanupClosePushL(dbView);

    User::LeaveIfError(dbView.Prepare(iDatabase, TDbQuery(sql), RDbView::EReadOnly ));

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

    //Get the note property from the database for the given key.

    TBool isAtRow(dbView.FirstL());

    if ( isAtRow )

        {

        retVal= ETrue; //Found 

        }

    CleanupStack::PopAndDestroy(&dbView); // dbView

    CPIXLOGSTRING("END CCPIXMDEDbManager::IsAlreadyExistL");

    return retVal; 

    }

void CCPIXMDEDbManager::GetItemL(const TInt aKey, CMDSEntity& aMdsItem)

    {

    CPIXLOGSTRING2("START CCPIXMDEDbManager::GetItemL aKey = %d",aKey);

    TInt err(KErrNone);

    //dataBase is not opened. return Not Ready

    if(!iOpened)

        {

        User::Leave(KErrNotReady);

        }

    TBuf<KMdeCpixSyncDbSqlDeleteSize> sql;

    sql.Format(KMdeCpixSyncDbSqlCheckExist, aKey);

    //Prepare the view

    RDbView dbView;

    CleanupClosePushL(dbView);

    User::LeaveIfError(dbView.Prepare(iDatabase, TDbQuery(sql), RDbView::EReadOnly ));

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

    //Get the note property from the database for the given key.

    TBool isAtRow(dbView.FirstL());

    if ( isAtRow )

        {

        //HBufC* content = NULL;

        dbView.GetL();

        //Get the key and modified time

        TInt key = dbView.ColInt32(EKey);

        TInt drive = dbView.ColInt32(EDrive);

        RDbColReadStream blob;

        blob.OpenLC(dbView, EUri);

        //Get the length of the content.

        TInt colLength( dbView.ColLength(EUri));

        //Get the length of the content to be read as filename       

        TInt uriLength(0);

        if(colLength > KMaxFileName )

            {

            uriLength = KMaxFileName;            

            }

        else

            {

            uriLength = colLength;

            }       

        //Create the buffer to get the filename

        HBufC* content = HBufC::NewLC(uriLength);

        TPtr ptr = content->Des();            

        //read the data from the database for the given length

        blob.ReadL(ptr,uriLength);         

        //Set the properties of the note to the Note Entity.

        TDriveNumber drivenumber = TDriveNumber(drive);

        aMdsItem.Set(key,*content,drivenumber);

        CleanupStack::PopAndDestroy( content ); // content

        //CleanupStack::Pop(content); // content

        //delete content;

        CleanupStack::PopAndDestroy(&blob); // blob

        }

    else 

        {

        //return not found for an invlaid key.

        err = KErrNotFound;

        }

    CleanupStack::PopAndDestroy(&dbView); // dbView/

    CPIXLOGSTRING2("END CCPIXMDEDbManager::GetItemL err = %d",err);

    User::LeaveIfError(err);      

    }

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

// CNotesPlugin::ResetL

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

//

TCPIXMDEDBAPIReturnType CCPIXMDEDbManager::ResetL()

    {

    CPIXLOGSTRING("START CCPIXMDEDbManager::ResetL");

    TCPIXMDEDBAPIReturnType retVal = EOperationUndefined;

    TBuf<KMdeCpixSyncDbSqlDeleteSize> sql;

    sql.Copy(KMdeCpixSyncDbSqlInsert);

    iDatabase.Begin();

    //Prepare the view

    RDbView dbView;

    CleanupClosePushL(dbView);

    User::LeaveIfError(dbView.Prepare(iDatabase, TDbQuery(sql)));

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

    CPIXLOGSTRING2("CCPIXMDEDbManager::ResetL dbView.CountL = %d",dbView.CountL());

    while(dbView.NextL())

        {

#ifdef _DEBUG

        TRAPD(err,dbView.DeleteL());

        CPIXLOGSTRING2("CCPIXMDEDbManager::ResetL dbView.DeleteL success err = %d",err);

#else

        TRAP_IGNORE( dbView.DeleteL() );

#endif

        }

    if(dbView.CountL() == 0)

        {

        CPIXLOGSTRING("CCPIXMDEDbManager::ResetL Success!"); 

        retVal= EOperationSuccess;

        }

    else

        {

        CPIXLOGSTRING("CCPIXMDEDbManager::ResetL Failure!");

        retVal= EOperationFailure;

        }

    CleanupStack::PopAndDestroy(1); // Myview

    if(retVal == EOperationSuccess)

        {

        iDatabase.Commit();

        iDatabase.Compact();

        }

    else

        {

        iDatabase.Rollback();

        }

    CPIXLOGSTRING("END CCPIXMDEDbManager::ResetL");

    return retVal; 

    }

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

// CMTPNotesDpDataController::Rollback

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

//

void CCPIXMDEDbManager::Rollback()

    {

    iDatabase.Rollback();

    if ( iDatabase.IsDamaged() )

        {

        iDatabase.Recover();

        }

    }

// End of file