/** @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:  Database for MediaServer

 *

*/

// INCLUDE FILES

#include <barsread.h>

#include <barsc.h>   

#include <f32file.h>

#include <sysutil.h>

#include <upnpdominterface.h>

#include <upnpstring.h>

#include "upnpprotocolinfo.h"

#include "upnpfileutils.h"

#include "upnpcontentdirectorydb.h"

#include "upnpcontentdirectoryglobals.h"

#include "upnpelementfactory.h"

#include "upnpelementbean.h"

#include "upnpobjectbean.h"

#include "upnpattributebean.h"

#include "upnpfilterelement.h"

#include "upnpresourcesbean.h"

#include "upnpcdutils.h"

#include "upnpcddbfactory.h"

#include "upnpmetadatastorage.h"

#define KLogFile _L("ContentDirectoryDb.log")

#include "upnpcustomlog.h"

// ============================= LOCAL FUNCTIONS ===============================

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

// CleanupFilterElementPointerArray

// Used by TCleanupItem to clean a RPointerArray<CUpnpFilterElement>

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

//

void CleanupFilterElementPointerArray( TAny* aArray )

    {

    (reinterpret_cast<RPointerArray<CUpnpFilterElement>*> (aArray))->ResetAndDestroy( );

    }

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

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

// CUpnpContentDirectoryDb::CUpnpContentDirectoryDb

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

// might leave.

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

//

CUpnpContentDirectoryDb::CUpnpContentDirectoryDb(

    CUpnpMetadataStorage* aMetadataStorage )

    {

    iMetadataStorage =aMetadataStorage;

    }

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

// CUpnpContentDirectoryDb::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUpnpContentDirectoryDb::ConstructL()

    {

    iDOMImpl.OpenL( );

    }

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

// CUpnpContentDirectoryDb::NewLC

// Two-phased constructor.

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

//

CUpnpContentDirectoryDb* CUpnpContentDirectoryDb::NewLC(

    CUpnpMetadataStorage* aMetadataStorage )

    {

    CUpnpContentDirectoryDb* self = new ( ELeave ) CUpnpContentDirectoryDb(aMetadataStorage);

    CleanupStack::PushL( self );

    self->ConstructL( );

    return self;

    }

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

// CUpnpContentDirectoryDb::NewL

// Two-phased constructor.

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

//

CUpnpContentDirectoryDb* CUpnpContentDirectoryDb::NewL(

    CUpnpMetadataStorage* aMetadataStorage )

    {

    CUpnpContentDirectoryDb* self = NewLC( aMetadataStorage );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpContentDirectoryDb::~~CUpnpContentDirectoryDb

// Destructor

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

//

CUpnpContentDirectoryDb::~CUpnpContentDirectoryDb()

    {

    iDOMImpl.Close( );

    LOGCD( "CUpnpContentDirectoryDb::~CUpnpContentDirectoryDb", "", 0,

        "DataBase closed" );

    }

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

// CUpnpContentDirectoryDb::InsertObjectL

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

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

//

TUpnpErrorCode CUpnpContentDirectoryDb::InsertObjectL(

    RXmlEngDocument& aFragment, TInt aContainerId, TInt* aId )

    {

    TUpnpErrorCode ret( EUpnpUndefined );

    // get object element

    TXmlEngElement element = UpnpCdUtils::GetObjectElementL( aFragment );

    // start transaction

    iMetadataStorage->BeginTransactionL( );

    TRAPD( err, ret = DoInsertObjectL( element, aContainerId, aId ) );

    if ( err )

        { // rollback if error

        iMetadataStorage->RollbackTransactionL( );

        User::Leave( err );

        }

    iMetadataStorage->CommitTransactionL( );

    return ret;

    }

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

// CUpnpContentDirectoryDb::GetObjectListL

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

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

//

TUpnpErrorCode CUpnpContentDirectoryDb::GetObjectListL( TInt aParentId,

    RArray<TInt>& aList )

    {

    return iMetadataStorage->GetObjectListL( aParentId, aList );

    }

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

// CUpnpContentDirectoryDb::GetObjectListL

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

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

//

void CUpnpContentDirectoryDb::GetObjectListL( const RArray<TInt>& aIds,

    const TDesC8& aFilter, RArray<RXmlEngDocument>& aObjs )

    {

    for ( TInt i = 0; i < aIds.Count( ); i++ )

        {

        RXmlEngDocument obj;

        CleanupClosePushL( obj );

        GetObjectL( aIds[i], obj, aFilter );

        aObjs.AppendL( obj );

        CleanupStack::Pop( &obj );

        }

    }

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

// CUpnpContentDirectoryDb::DeleteObjectL

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

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

//

TUpnpErrorCode CUpnpContentDirectoryDb::DeleteObjectL( TInt aObjId,

    RArray<TInt>& aRefList, TBool aDeleteResource )

    {

    return iMetadataStorage->DeleteObjectL( aObjId, aRefList, aDeleteResource );

    }

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

// CUpnpContentDirectoryDb::UpdateObjectL

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

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

//

TUpnpErrorCode CUpnpContentDirectoryDb::UpdateObjectL( TInt aObjId,

    RXmlEngDocument& aFragment )

    {

    TUpnpErrorCode ret = EUpnpUndefined;

    // // get object element

    TXmlEngElement element = UpnpCdUtils::GetObjectElementL( aFragment );

    // start transaction

    iMetadataStorage->BeginTransactionL( );

    TRAPD( err, ret = DoUpdateObjectL( aObjId, element ) );

    if ( err )

        { // rollback - error

        iMetadataStorage->RollbackTransactionL( );

        User::Leave( err );

        }

    // commit if success

    iMetadataStorage->CommitTransactionL( );

    return ret;

    }

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

// CUpnpContentDirectoryDb::DoUpdateObjectL

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

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

//

TUpnpErrorCode CUpnpContentDirectoryDb::DoUpdateObjectL( TInt aObjId,

    TXmlEngElement aFragment )

    {

    TUpnpErrorCode ret = EUpnpUndefined;

    // delete object

    ret = iMetadataStorage->DoDeleteObjectL( aObjId, EFalse, EFalse );

    TXmlEngElement el = aFragment;

    ret = InsertUpdatedL( aObjId, el );

    return ret;

    }

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

// CUpnpContentDirectoryDb::InsertUpdatedL

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

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

//

TUpnpErrorCode CUpnpContentDirectoryDb::InsertUpdatedL( TInt aObjId,

    TXmlEngElement& aElement )

    {

    TUpnpErrorCode ret = EUpnpUndefined;

    iMetadataStorage->InsertObjectIntoObjectTableL( aElement );

    ret = EUpnpOk;

    RXmlEngNodeList<TXmlEngElement> elements;

    CleanupClosePushL( elements );

    aElement.GetChildElements( elements );

    while ( elements.HasNext( ) )

        {

        TXmlEngElement el = elements.Next( );

        if ( el.Name().CompareF( KClassTagName ) && el.Name().CompareF( KTitleTagName ) )

            {

            ret = InsertElementL( el, aObjId );

            }

        else

            {

            UpnpCdUtils::IsElementRequiredL( el ); // just remove the marker attr

            }

        }

    CleanupStack::PopAndDestroy( &elements );

    return ret;

    }

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

// CUpnpContentDirectoryDb::InsertElementL

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

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

//

TUpnpErrorCode CUpnpContentDirectoryDb::InsertElementL(

    const TXmlEngElement& aElement, TInt aObjId )

    {

    return InsertAttributesL( aElement, iMetadataStorage->InsertElementL(

        aElement, aObjId ), aObjId );

    }

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

// CUpnpContentDirectoryDb::PrepareDidlDocumentL

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

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

//

RXmlEngDocument CUpnpContentDirectoryDb::PrepareDidlDocumentL()

    {

    RXmlEngDocument doc;

    doc.OpenL( iDOMImpl );

    TXmlEngElement el = doc.CreateDocumentElementL( KDidlLite( ) );

    el.AddNamespaceDeclarationL( KXmlnsNsUri( ), KCmlnsNsPref( ) );

    el.AddNamespaceDeclarationL( KDcNsUri( ), KDcNsPref( ) );

    el.AddNamespaceDeclarationL( KUpnpNsUri( ), KUpnpNsPref( ) );

    return doc;

    }

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

// CUpnpContentDirectoryDb::CheckObjectRestrictionL

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

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

//

TUpnpErrorCode CUpnpContentDirectoryDb::CheckObjectRestrictionL( TInt aObjId )

    {

    return iMetadataStorage->CheckObjectRestrictionL( aObjId );

    }

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

// CUpnpContentDirectoryDb::GetObjectL

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

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

TUpnpErrorCode CUpnpContentDirectoryDb::GetObjectL( TInt aObjectID,

    RXmlEngDocument& aDoc, const TDesC8& aFilterString )

    {

    TUpnpErrorCode ret = EUpnpUndefined;

    if ( aFilterString == KAsterisk8 )

        { // get the whole object

        ret = DoGetObjectL( aObjectID, aDoc, ETrue );

        }

    else if ( !aFilterString.Length( ) )

        { // get only required properties

        ret = DoGetObjectL( aObjectID, aDoc, EFalse );

        }

    else

        {

        RXmlEngDocument doc; // before the whole obj is created do not change the given reference,

        CleanupClosePushL( doc ); // it prevents from returning not completed object if something goes wrong 

        // during construction of response object

        // get required properties

        ret = DoGetObjectL( aObjectID, doc, EFalse );

        if ( ret == EUpnpOk ) // do not not continue if something went wrong

            {

            // prepare a list of filter elements

            RPointerArray<CUpnpFilterElement> filterElements;

            TCleanupItem cleanupItem( CleanupFilterElementPointerArray,

                &filterElements );

            CleanupStack::PushL( cleanupItem );

            // parse filter string

            ParseFilterStringL( aFilterString, filterElements );

            // add requested elements

            AddRequestedPropertiesL( aObjectID,

                UpnpCdUtils::GetObjectElementL( doc ), filterElements ); // ignore if error

            //clean up

            CleanupStack::PopAndDestroy( &filterElements );

            }

        if ( ret == EUpnpOk )

            { // object is completed

            aDoc = doc;

            CleanupStack::Pop( &doc );

            }

        else

            { // something went wrong

            CleanupStack::PopAndDestroy( &doc );

            }

        }

    return ret;

    }

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

// CUpnpContentDirectoryDb::GetObjectL

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

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

TUpnpErrorCode CUpnpContentDirectoryDb::AddRequestedPropertiesL(

    TInt aObjectID, TXmlEngElement aElement,

    const RPointerArray<CUpnpFilterElement>& aFilterElements )

    {

    TUpnpErrorCode ret = EUpnpUndefined;

    // aFilterElements must be sorted

    for ( TInt i = 0; i < aFilterElements.Count( ); i++ )

        {

        const CUpnpFilterElement* filter = aFilterElements[i];

        if ( filter->ElementName().Length( ) )

            { // element part defined

            AddElementL( aElement, aObjectID, filter );

            }

        else

            { // element part not defined - it is attribute of main element tag

            for ( TInt j = 0; j < filter->Count( ); j++ )

                {

                if ( (*filter)[j] == KChildCount )

                    {

                    SetChildCountL( aElement, aObjectID );

                    ret = EUpnpOk;

                    }

                else

                    {

                    ret = iMetadataStorage->AddMainTagAttrL( aElement,

                        aObjectID, (*filter)[j] );

                    }

                }

            }

        }

    return ret;

    }

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

// CUpnpContentDirectoryDb::SetChildCountL

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

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

void CUpnpContentDirectoryDb::SetChildCountL( TXmlEngElement aElement,

    TInt aId )

    {

    if ( aElement.Name( ) == KContainer )

        {

        // value

        TInt childCount = iMetadataStorage->GetChildCountL( aId );

        TBuf8<KMaxIntegerLen> num;

        num.Num( childCount );

        // is it already exist?

        TXmlEngAttr childAttr = aElement.AttributeNodeL( KChildCount( ) );

        if ( childAttr.IsNull( ) )

            { // not exist - add 

            aElement.AddNewAttributeL( KChildCount( ), num );

            }

        else

            { // already exists - update

            childAttr.SetValueL( num );

            }

        }

    }

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

// CUpnpContentDirectoryDb::AddElementL

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

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

void CUpnpContentDirectoryDb::AddElementL( TXmlEngElement aElement,

    TInt aObjectID, const CUpnpFilterElement* aReqElement )

    {

    // get elements from database

    RDbView view = iMetadataStorage->GetElementViewL( aObjectID,

        aReqElement->ElementName( ) );

    CleanupClosePushL( view );

    // for each element found

    while ( view.NextL( ) )

        {

        view.GetL( );

        CUpnpElementBean* elBean = CUpnpElementBean::NewLC( view );

        // add element

        TXmlEngElement newElement = elBean->AttachElmL( aElement );

        // add required attributes

        AddAttributesL( elBean->ElmId( ), aObjectID, newElement, EFalse );

        // for each requested attribute

        for ( TInt i = 0; i < aReqElement->Count( ); i++ )

            {

            TPtrC8 attrNamePtr((*aReqElement)[i]);

            TXmlEngAttr attr = newElement.AttributeNodeL( attrNamePtr );

            // add if not present

            // ignore if element has not any attribute

            if ( attr.IsNull( ) && elBean->ElmHasAttribute( ) )

                {

                AddAttributeL( newElement, attrNamePtr, elBean->ElmId( ),

                    aObjectID );

                }

            }

        // clean up

        CleanupStack::PopAndDestroy( elBean );

        }

    // clean up

    CleanupStack::PopAndDestroy( &view );

    }

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

// CUpnpContentDirectoryDb::ParseFilterStringL

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

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

//

void CUpnpContentDirectoryDb::ParseFilterStringL( const TDesC8& aFilter,

    RPointerArray<CUpnpFilterElement>& aList )

    {

    // separate filter's parts

    CDesC8ArrayFlat* list = new(ELeave) CDesC8ArrayFlat(KDefaultGranularity);

    CleanupStack::PushL( list );

    TInt commaPos;

    TPtrC8 filter(aFilter);

    while ( (commaPos = filter.Find( KCommaStr8( ) ) ) != KErrNotFound )

        {

        HBufC8* buf = filter.Left(commaPos).AllocLC( );

        buf->Des().TrimAll( );

        list->AppendL( *buf );

        filter.Set( filter.Mid( commaPos+1 ) );

        CleanupStack::PopAndDestroy( buf );

        }

    // add last

    HBufC8* buf = filter.AllocLC( );

    buf->Des().TrimAll( );

    list->AppendL( *buf );

    filter.Set( filter.Mid( commaPos+1 ) );

    CleanupStack::PopAndDestroy( buf );

    // sort to simplify

    list->Sort( );

    TPtrC8 curr( KMinusOne8 );

    for ( TInt i = 0; i< list->Count( ); i++ ) // for each filter property

        {

        // split filter string - element@attribute

        TInt atPos = (*list)[i].Find( KAtStr8 );

        TPtrC8 attr;

        if ( atPos == KErrNotFound ) // is it element name

            { // it is element

            attr.Set( KNullDesC8 );

            atPos = (*list)[i].Length( );

            }

        else

            {

            attr.Set( (*list)[i].Mid( atPos+1 ) );

            }

        TPtrC8 element((*list)[i].Left( atPos ) );

        // do not add "class" and "title" elements - required by default

        if ( element.CompareF( KClassTagNameWithNs8 )

                && element.CompareF( KTitleTagNameWithNs8 ) )

            { // it is neither a class nor title element

            if ( element == curr )

                { // already exists, add next attribute

                if ( attr.Length( ) ) // ignore empty attr

                    aList[aList.Count()-1]->AppendAttributeL( attr );

                }

            else

                { // create new filter element

                CUpnpFilterElement* tmp = CUpnpFilterElement::NewLC( );

                tmp->SetElementNameL( element );

                if ( attr.Length( ) ) // ignore epmty attr

                    tmp->AppendAttributeL( attr );

                aList.AppendL( tmp );

                CleanupStack::Pop( tmp );

                curr.Set( element );

                }

            }

        }

    // clean up

    CleanupStack::PopAndDestroy( list );

    }

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

// CUpnpContentDirectoryDb::DoGetObjectL

// Function returns DIDL-Lite XML fragment with metadata for requested object.

// IMPORTANT: 1. Caller takes responsibility for returned document and is 

//              obliged to close it.

//           2. The root element of the document is <DIDL-Lite> element and

//              the object's element is its direct, onluy child.