/** @file

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

 *

*/

// INCLUDE FILES

#include <upnpdominterface.h>

#include "upnpmetadatastorage.h"

#include "upnpcontentdirectoryglobals.h"

#include "upnpobjectbean.h"

#include "upnpelementbean.h"

#include "upnpcdutils.h"

#include "upnpresourcesbean.h"

#include "upnpitem.h"

#include "upnpelement.h"

#include "upnpattributebean.h"

#include "upnpcddbfactory.h"

#define KLogFile _L("ContentDirectoryDb.log")

#include "upnpcustomlog.h"

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

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

// CUpnpMetadataStorage::CUpnpMetadataStorage

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CUpnpMetadataStorage::CUpnpMetadataStorage()

    {

    }

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

// CUpnpMetadataStorage::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUpnpMetadataStorage::ConstructL( const TDesC& aDatabaseFileName )

    {

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

    OpenDbL( aDatabaseFileName );

    }

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

// CUpnpMetadataStorage::NewL

// Two-phased constructor.

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

//

CUpnpMetadataStorage* CUpnpMetadataStorage::NewLC(

    const TDesC& aDatabaseFileName )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aDatabaseFileName );

    return self;

    }

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

// CUpnpMetadataStorage::NewL

// Two-phased constructor.

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

//

CUpnpMetadataStorage* CUpnpMetadataStorage::NewL(

    const TDesC& aDatabaseFileName )

    {

    CUpnpMetadataStorage* self =

            CUpnpMetadataStorage::NewLC( aDatabaseFileName );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpMetadataStorage::~CUpnpMetadataStorage

// Destructor

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

//    

CUpnpMetadataStorage::~CUpnpMetadataStorage()

    {

    if ( iIsOpen )

        {

        iDatabase.Compact( );

        }

    iDatabase.Close( );

    delete iFileStore;

    iFsSession.Close( );

    }

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

// CUpnpMetadataStorage::OpenDbL

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

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

//

void CUpnpMetadataStorage::OpenDbL( const TFileName& aDatabaseFileName )

    {

    iFileStore = CPermanentFileStore::OpenL( iFsSession, aDatabaseFileName,

        EFileRead|EFileWrite );

    iFileStore->SetTypeL( iFileStore->Layout( ) );

    iDatabase.OpenL( iFileStore, iFileStore->Root( ) );

    CheckDatabaseL( );

    iIsOpen = ETrue;

    }

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

// CUpnpMetadataStorage::DbChangedL

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

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

//

void CUpnpMetadataStorage::DbChangedL( TInt aWeight )

    {

    iCompactCounter += aWeight;

    }

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

// CUpnpMetadataStorage::DbChangedL

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

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

//

void CUpnpMetadataStorage::CompactDbL()

    {

    if ( iCompactCounter >= KCompactWeight )

        {

        iCompactCounter = 0;

        User::LeaveIfError( iDatabase.Compact( ) );

        }

    }

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

// CUpnpMetadataStorage::BeginTransactionL

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

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

//

void CUpnpMetadataStorage::BeginTransactionL()

    {

    iDatabase.Begin( );

    }

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

// CUpnpMetadataStorage::CommitTransactionL

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

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

//

void CUpnpMetadataStorage::CommitTransactionL()

    {

    TInt err = iDatabase.Commit( );

    if ( err != KErrNone )

        {

        iDatabase.Rollback( );

        User::LeaveIfError( iDatabase.Recover( ) );

        User::Leave( err );

        }

    CompactDbL( );

    }

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

// CUpnpMetadataStorage::RollbackTransactionL

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

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

//

void CUpnpMetadataStorage::RollbackTransactionL()

    {

    iDatabase.Rollback( );

    User::LeaveIfError( iDatabase.Recover( ) );

    }

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

// CUpnpMetadataStorage::GetObjectListL

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

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

//

TUpnpErrorCode CUpnpMetadataStorage::GetObjectListL( TInt aParentId,

    RArray<TInt>& aList )

    {

    TUpnpErrorCode ret = CheckObjectRestrictionL( aParentId ); // make sure the parent exists

    if ( ret != ENoSuchObject && ret != ENoContainer )

        {

        // prepare query

        TBuf<sizeof(KGetObjectListSqlCmd)/KCharSize + KMaxIntegerLen> query;

        query.Format( KGetObjectListSqlCmd, aParentId );

        // prepare view

        RDbView view;

        User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( query ),

            view.EReadOnly ) );

        CleanupClosePushL( view );

        // evaluate

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

        // for each object

        const TInt KIdColNo=1;

        while ( view.NextL( ) )

            {

            view.GetL( );

            // get object

            TInt childId = view.ColInt( KIdColNo );

            aList.AppendL( childId );

            }

        //clean up

        CleanupStack::PopAndDestroy( &view );

        ret = EUpnpOk;

        }

    return ret;

    }

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

// CUpnpMetadataStorage::GetObjectListL

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

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

//

TUpnpErrorCode CUpnpMetadataStorage::GetItemListL( TInt aParentId,

    RArray<TInt>& aList )

    {

    TUpnpErrorCode ret = CheckObjectRestrictionL( aParentId ); // make sure the parent exists

    if ( ret != ENoSuchObject )

        {

        // prepare query

        TBuf<sizeof(KGetItemListSqlCmd)/KCharSize + KMaxIntegerLen> query;

        query.Format( KGetItemListSqlCmd, aParentId );

        // prepare view

        RDbView view;

        User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( query ),

            view.EReadOnly ) );

        CleanupClosePushL( view );

        // evaluate

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

        // for each object

        const TInt KIdColNo=1;

        while ( view.NextL( ) )

            {

            view.GetL( );

            // get object

            TInt childId = view.ColInt( KIdColNo );

            aList.AppendL( childId );

            }

        //clean up

        CleanupStack::PopAndDestroy( &view );

        ret = EUpnpOk;

        }

    return ret;

    }

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

// CUpnpMetadataStorage::GetContainerListL

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

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

//

TUpnpErrorCode CUpnpMetadataStorage::GetContainerListL( TInt aParentId,

    RArray<TInt>& aList )

    {

    TUpnpErrorCode ret = CheckObjectRestrictionL( aParentId ); // make sure the parent exists

    if ( ret != ENoSuchObject )

        {

        // prepare query

        TBuf<sizeof(KGetContainerListSqlCmd)/KCharSize + KMaxIntegerLen> query;

        query.Format( KGetContainerListSqlCmd, aParentId );

        // prepare view

        RDbView view;

        User::LeaveIfError( view.Prepare( iDatabase, TDbQuery( query ),

            view.EReadOnly ) );

        CleanupClosePushL( view );

        // evaluate

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

        // for each object

        const TInt KIdColNo=1;

        while ( view.NextL( ) )

            {

            view.GetL( );

            // get object

            TInt childId = view.ColInt( KIdColNo );

            aList.AppendL( childId );

            }

        //clean up

        CleanupStack::PopAndDestroy( &view );

        ret = EUpnpOk;

        }

    return ret;

    }

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

// CUpnpMetadataStorage::CheckObjectRestrictionL

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

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

//

TUpnpErrorCode CUpnpMetadataStorage::CheckObjectRestrictionL( TInt aObjId )

    {

    TUpnpErrorCode ret = EUpnpUndefined;

    RDbTable table;

    CleanupClosePushL( table );

    TDbSeekKey seekKey(aObjId);

    User::LeaveIfError( table.Open( iDatabase, KObjectTableName,

        table.EReadOnly ) );

    User::LeaveIfError( table.SetIndex( KObjIdIndexName ) ); // use index

    if ( table.SeekL( seekKey ) ) // find object

        { // object found

        table.GetL( );

        CDbColSet* colSet = table.ColSetL( );

        TDbColNo colNo(colSet->ColNo( KObjRestrictedColName ) );

        if ( !table.ColUint8( colNo ) ) // is restricted?

            { // OK

            TDbColNo colNo(colSet->ColNo( KObjClassColName ) );

            if ( table.ColDes8(colNo).Find( KContainerClass8 ) == 0 ) // check whether the object is a container

                { // this is a container

                ret = EUpnpOk;

                }

            else

                { // there is such object but this is not a container

                ret = ENoContainer;

                }

            }

        else

            {

            ret = ERestrictedObject;

            }

        delete colSet;

        }

    else

        { // no such object

        ret = ENoSuchObject;

        }

    CleanupStack::PopAndDestroy( &table );

    return ret;

    }

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

// CUpnpMetadataStorage::CheckObjectRestrictionL

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

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

//

TBool CUpnpMetadataStorage::IsContainerL( TInt aObjId )

    {

    TBool ret = EFalse;

    RDbTable table;

    CleanupClosePushL( table );

    TDbSeekKey seekKey(aObjId);

    User::LeaveIfError( table.Open( iDatabase, KObjectTableName,

        table.EReadOnly ) );

    User::LeaveIfError( table.SetIndex( KObjIdIndexName ) ); // use index

    if ( table.SeekL( seekKey ) ) // find object

        { // object found

        table.GetL( );

        CDbColSet* colSet = table.ColSetL( );

        TDbColNo colNo(colSet->ColNo( KObjClassColName ) );

        if ( table.ColDes8(colNo).Find( KContainerClass8 ) == 0 ) // check whether the object is a container

            { // this is a container

            ret = ETrue;

            }

        delete colSet;

        }

    // clean up

    CleanupStack::PopAndDestroy( &table );

    return ret;

    }

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

// CUpnpMetadataStorage::AddMainTagAttrL

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

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

TUpnpErrorCode CUpnpMetadataStorage::AddMainTagAttrL(

    TXmlEngElement aElement, TInt aId, const TDesC8& aName )

    {

    TUpnpErrorCode ret = EUpnpUndefined;

    // xml string of name

    // is the attr exist?

    TXmlEngAttr atr = aElement.AttributeNodeL( aName );

    if ( atr.IsNull( ) )

        { // attr does not exist - add

        TBuf<sizeof(KSelectFromObjectSqlCmd)/KCharSize +

        KMaxIntegerLen + KColNameMaxLenth> query;

        query.Format( KSelectFromObjectSqlCmd, &aName, aId );

        // Execute command

        RDbView view;

        CleanupClosePushL( view );

        TInt dbErr = view.Prepare( iDatabase, TDbQuery( query ),

            view.EReadOnly );

        LOGSQL( "CUpnpContentDirectoryDb::AddMainTagAttrL",

            "RDbView::Prepare", dbErr, &query );

        if ( dbErr == KErrNone )

            {

            CleanupClosePushL( view );

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

            // if there is a row, add attribute

            if ( view.FirstL( ) )

                {

                // get row

                view.GetL( );

                // col's val as Des

                HBufC8* buff = GetColDesValFromRowSetL( view, 1 );

                CleanupStack::PushL( buff );

                // prepare xml string of value

                // add attributes

                aElement.AddNewAttributeL( aName, *buff );

                ret = EUpnpOk;

                // clean up

                CleanupStack::PopAndDestroy( buff );

                }

            else

                { // no such object in the database

                ret = ENoSuchObject;

                }

            }

        else

            { // probably the name of the attr was wrong - ignore

            ret = ENoSuchObject;

            }

        // clean up

        CleanupStack::PopAndDestroy( &view );

        }

    else // if(!atr.IsNull())

        { // already exists - it is OK, do not need to do anything

        ret = EUpnpOk;

        }

    return ret;

    }

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

// CUpnpMetadataStorage::GetElementViewL

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

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

RDbView CUpnpMetadataStorage::GetElementViewL( TInt aObjId,

    const TDesC8& aElName )

    {

    // convert to TDesC

    HBufC* elName = HBufC::NewLC( aElName.Length( ) );

    elName->Des().Copy( aElName );

    // Prepare SQL command

    HBufC* query = HBufC::NewLC( KSelectElmFromElmSqlCmd().Length( ) 

                                + KNamedElFromElement().Length( ) 

                                + KMaxIntegerLen 

                                + elName->Length( ) );

    TPtr queryPtr(query->Des( ));

    queryPtr.Format( KSelectElmFromElmSqlCmd, aObjId );

    queryPtr.AppendFormat( KNamedElFromElement, elName );

    // Execute command

    RDbView view = GetEvaluatedViewL( queryPtr );

    LOGSQL( "CUpnpContentDirectoryDb::GetElementViewL", "RDbView::Prepare",

        0, &queryPtr );

    CleanupStack::PopAndDestroy( query );

    CleanupStack::PopAndDestroy( elName );

    return view;

    }

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

// CUpnpMetadataStorage::AddAttributeL

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

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

//

RDbView CUpnpMetadataStorage::GetObjViewL( TInt aObjId )

    {

    // Get data from object table

    // Prepare SQL command

    TBuf<sizeof(KSelectObjectFromObjSqlCmd)/KCharSize

    + KMaxIntegerLen> query;

    query.Format( KSelectObjectFromObjSqlCmd, aObjId );

    LOGSQL( "CUpnpContentDirectoryDb::GetObjectL", "", 0, &query );

    return GetEvaluatedViewL( query );

    }

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

// CUpnpMetadataStorage::AddAttributeL

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

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

//

RDbView CUpnpMetadataStorage::GetElementsViewL( TInt aObjectID, TBool aAll )

    {

    // Get data from element table

    // Prepare SQL command

    TBuf<sizeof(KSelectElmFromElmSqlCmd)/KCharSize

    + sizeof(KOnlyRequiredFromElement)/KCharSize + KMaxIntegerLen> query;

    query.Format( KSelectElmFromElmSqlCmd, aObjectID );

    query.Format( KSelectElmFromElmSqlCmd, aObjectID );

    if ( !aAll )

        { // only required properties

        query.Append( KOnlyRequiredFromElement );

        }