/*

* Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*      Implementation of class RFavouritesSrvTable

*      

*

*/

// INCLUDE FILES

#include <s32strm.h>

#include "FavouritesSrvTable.h"

#include "FavouritesPanic.h"

#include "FavouritesFilter.h"

// CONSTANTS

/// Buffer size for formatting SQL query in SetFiltersL().

const TInt KFavouritesMaxSql = 255;

// Database table names.

/// Favourites table name.

_LIT( KFavouritesTableName, "Favourites" );

// Database column names.                                       // First in:

/// "Uid" column name.

_LIT( KFavouritesDbUidColName, "Uid" );                         // 6.6

/// "Parent folder" column name.

_LIT( KFavouritesDbParentColName, "Parent" );                   // 6.6

/// "Type" column name.

_LIT( KFavouritesDbTypeColName, "Type" );                       // 6.6

/// "Name" column name.

_LIT( KFavouritesDbNameColName, "Name" );                       // 6.6

/// "URL" column name.

_LIT( KFavouritesDbUrlColName, "Url" );                         // 6.6

/// "WAP AP ApId" column name.

_LIT( KFavouritesDbApIdColName, "WapApId" );                    // 6.6

/// "WAP AP Value Kind" column name.

_LIT( KFavouritesDbApValueKindColName, "WapApValueKind" );      // 6.6

/// "Username" column name.

_LIT( KFavouritesDbUserNameColName, "Username" );               // 6.6

/// "Password" column name.

_LIT( KFavouritesDbPasswordColName, "Password" );               // 6.6

/// "Derived classes' extra data" column name.

_LIT( KFavouritesDbExtraDataColName, "ExtraData" );             // 6.6

/// "Factory item" column name.

_LIT( KFavouritesDbFactoryItemColName, "FactoryItem" );         // 6.6

/// "Read-only" column name.

_LIT( KFavouritesDbReadOnlyColName, "ReadOnly" );               // 7.0

/// "ContextId" column name.

_LIT( KFavouritesDbContextIdColName, "ContextId" );             // 7.0

/// "Modified" column name.

_LIT( KFavouritesDbModifiedColName, "Modified" );               // 8.0

/// "Preferred Uid" column name.

_LIT( KFavouritesDbPrefUidColName, "PrefUid" );                 // 9.0

/// "Derived classes' extra data" column name.

_LIT( KFavouritesDbBrowserDataColName, "BrowserData" );         // 10.0

_LIT( KFavouritesDbHiddenColName, "Hidden" );                   // 11.0

// Index column names.

/// "Index by Uid" column name.

_LIT( KFavouritesDbUidIdxName, "UidIdx" );

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

/**

* Append escaped aLiteral to the end of aBuffer. This means appenging aLiteral,

* with all '-s changed to ''-s.

* @param aBuffer Buffer to append to.

* @param aLiteral Literal to append escaped.

*/

LOCAL_C void AppendEscaped( TDes& aBuffer, const TDesC& aLiteral )

    {

    TInt i;

    TUint quote('\'');  // TChar gives warnings in THUMB & ARMI

    for ( i = 0; i < aLiteral.Length(); i++ )

        {

        aBuffer.Append( aLiteral[i] );

        if ( aLiteral[i] == quote )

            {

            // Duplicate quote.

            aBuffer.Append( quote );

            }

        }

    }

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

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

// RFavouritesSrvTable::OpenL

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

//

void RFavouritesSrvTable::OpenL

        (

        RDbNamedDatabase& aDb,

        RDbRowSet::TAccess aAccess /*=RDbRowSet::EUpdatable*/

        )

    {

    iFiltering = EFalse;

    User::LeaveIfError( RDbTable::Open( aDb, KFavouritesTableName, aAccess ) );

    CleanupClosePushL<RDbTable>( *this );

    GetColumnNumbersL();

    CleanupStack::Pop();    // closing this

    SetIndex( KFavouritesDbUidIdxName );

    }

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

// RFavouritesSrvTable::Close

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

//

void RFavouritesSrvTable::Close()

    {

    ClearFilters();

    RDbTable::Close();

    }

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

// RFavouritesSrvTable::InsertLC

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

//

void RFavouritesSrvTable::InsertLC()

    {

    RDbTable::InsertL();

    CleanupStack::PushL( TCleanupItem( StaticCancel, this ) );

    }

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

// RFavouritesSrvTable::UpdateLC

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

//

void RFavouritesSrvTable::UpdateLC()

    {

    RDbTable::UpdateL();

    CleanupStack::PushL( TCleanupItem( StaticCancel, this ) );

    }

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

// RFavouritesSrvTable::PutL

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

//

void RFavouritesSrvTable::PutL( TBool aTouch /*=ETrue*/ )

    {

    if ( aTouch )

        {

        TTime now;

        now.UniversalTime();

        SetModifiedL( now );

        }

    RDbTable::PutL();

    CleanupStack::Pop();    // StaticCancel, pushed by InsertLC or UpdateLC.

    }

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

// RFavouritesSrvTable::Cancel

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

//

void RFavouritesSrvTable::Cancel()

    {

    // Any updates in this method must also be applied StaticCancel!

    RDbTable::Cancel();

    CleanupStack::Pop();    // StaticCancel, pushed by InsertLC or UpdateLC.

    }

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

// RFavouritesSrvTable::SetFiltersL

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

//

void RFavouritesSrvTable::SetFiltersL( const TFavouritesFilter& aFilter )

    {

    HBufC* buf = HBufC::NewLC( KFavouritesMaxSql );

    TPtr sql = buf->Des();

    HBufC* tmpBuf = HBufC::NewLC( KFavouritesMaxSql );

    TPtr tmpPtr = tmpBuf->Des();

    _LIT( KNone, "" );

    _LIT( KAnd, "and" );

    TPtrC sConn;

    sConn.Set( KNone );

    if ( aFilter.iName )

        {

        // "name like 'foo*'"

        _LIT( KFormat1, "%S like '" );

        sql.Format( KFormat1, &KFavouritesDbNameColName );

        AppendEscaped( sql, *aFilter.iName );

        sql.Append( TChar('\'') );

        sConn.Set( KAnd );

        }

    if ( aFilter.iType != CFavouritesItem::ENone )

        {

        // "and type = 0"

        _LIT( KFormat2, " %S %S = %d" );

        tmpPtr.Format

            ( KFormat2, &sConn, &KFavouritesDbTypeColName, aFilter.iType );

        sConn.Set( KAnd );

        sql.Append( tmpPtr );

        }

    if ( aFilter.iParentFolder != KFavouritesNullUid )

        {

        // "and parent = 7"

        _LIT( KFormat3, " %S %S = %d" );

        tmpPtr.Format( KFormat3,

            &sConn, &KFavouritesDbParentColName, aFilter.iParentFolder );

        sConn.Set( KAnd );

        sql.Append( tmpPtr );

        }

    if ( aFilter.iContextId != KFavouritesNullContextId )

        {

        // "and contextid = 7"

        _LIT( KFormat3, " %S %S = %d" );

        tmpPtr.Format( KFormat3,

            &sConn, &KFavouritesDbContextIdColName, aFilter.iContextId );

        sConn.Set( KAnd );

        sql.Append( tmpPtr );

        }

    // Clear old one, if any.

    ClearFilters();

    if ( sql.Length() > 0 )

        {

        // Make new constraint, if there is any filter set.

        // Otherwise there will be no constraint.

        User::LeaveIfError

            ( iFilter.Open( *this, TDbQuery( sql, EDbCompareFolded ) ) );

        iFiltering = ETrue;

        }

    CleanupStack::PopAndDestroy( 2 );  // tmpBuf, buf

    }

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

// RFavouritesSrvTable::ClearFilters

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

//

void RFavouritesSrvTable::ClearFilters()

    {

    if ( iFiltering )

        {

        iFilter.Close();

        iFiltering = EFalse;

        }

    }

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

// RFavouritesSrvTable::NextL

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

//

TBool RFavouritesSrvTable::NextL()

    {

    while ( RDbTable::NextL() )

        {

        // Use the filters, if any.

        if ( !iFiltering || MatchL( iFilter ) )

            {

            // We have a matching row.

            return ETrue;

            }

        }

    // No matching rows were found.

    return EFalse;

    }

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

// RFavouritesSrvTable::SeekToUidL

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

//

TBool RFavouritesSrvTable::SeekToUidL( TInt aUid )

    {

    return SeekL( TDbSeekKey( aUid ) );

    }

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

// RFavouritesSrvTable::GotoToUidL

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

//

void RFavouritesSrvTable::GotoToUidL( TInt aUid )

    {

    if ( !SeekToUidL( aUid ) )

        {

        User::Leave( KErrNotFound );

        }

    }

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

// RFavouritesSrvTable::ReadItemDataL

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

//

void RFavouritesSrvTable::ReadItemDataL( CFavouritesItemImpl& aItem ) const

    {

    // Fill standard attributes.

    aItem.SetUid( Uid() );

    // No bookmark can exist with the Null Uid.

    __ASSERT_DEBUG( aItem.Uid() != KFavouritesNullUid,

        FavouritesPanic( EFavouritesNullUidInDatabase ) );

    aItem.SetParentFolder( ParentFolder() );

    aItem.SetType( Type() );

    aItem.SetNameL( Name() );

    HBufC* url = UrlLC();

    aItem.SetUrlL( *url );

    CleanupStack::PopAndDestroy();  // url

    aItem.SetUserNameL( Username() );

    aItem.SetPasswordL( Password() );

    aItem.SetWapAp( WapAp() );

    aItem.SetFactoryItem( FactoryItem() );

    aItem.SetReadOnly( ReadOnly() );

    aItem.SetContextId( ContextId() );

    aItem.SetModified( Modified() );

    aItem.SetHidden( Hidden() );

    }

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

// RFavouritesSrvTable::Uid

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

//

TInt RFavouritesSrvTable::Uid() const

    {

    return ColInt( iColNoUid );

    }

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

// RFavouritesSrvTable::ParentFolder

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

//

TInt RFavouritesSrvTable::ParentFolder() const

    {

    return ColInt( iColNoParentFolder );

    }

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

// RFavouritesSrvTable::Type

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

//

CFavouritesItem::TType RFavouritesSrvTable::Type() const

    {

    return STATIC_CAST( CFavouritesItem::TType, ColInt32( iColNoType ) );

    }

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

// RFavouritesSrvTable::Name

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

//

TPtrC RFavouritesSrvTable::Name() const

    {

    return ColDes( iColNoName );

    }

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

// RFavouritesSrvTable::UrlLC

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

//

HBufC* RFavouritesSrvTable::UrlLC() const

    {

    // URL is long column.

    RDbColReadStream stream;

    TInt len = ColLength( iColNoUrl );

    HBufC* buf = HBufC::NewLC( len );

    if ( len )

        {

        stream.OpenLC( *this, iColNoUrl );

        TPtr ptr = buf->Des();

        stream.ReadL( ptr, len );

        CleanupStack::PopAndDestroy();  // Close stream

        }

    return buf;

    }

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

// RFavouritesSrvTable::WapAp

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

//

TFavouritesWapAp RFavouritesSrvTable::WapAp() const

    {

    TFavouritesWapAp wapAp;

    wapAp.iApId = ColUint32 ( iColNoWapApId );

    wapAp.iValueKind = STATIC_CAST

        ( TFavouritesWapAp::TValueKind, ColInt ( iColNoWapApValueKind ) );

    return wapAp;

    }

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

// RFavouritesSrvTable::Username

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

//

TPtrC RFavouritesSrvTable::Username() const

    {

    return ColDes( iColNoUserName );

    }

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

// RFavouritesSrvTable::Password

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

//

TPtrC RFavouritesSrvTable::Password() const

    {

    return ColDes( iColNoPassword );

    }

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

// RFavouritesSrvTable::GetExtraDataL

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

//

void RFavouritesSrvTable::GetExtraDataL( MStreamBuf& aSink )

    {

    RDbColReadStream rs;

    rs.OpenLC( *this, iColNoExtraData );

    RWriteStream ws( &aSink );

    rs.ReadL( ws );

    CleanupStack::PopAndDestroy();  // Close rs

    }

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

// RFavouritesSrvTable::GetBrowserDataL

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

//

void RFavouritesSrvTable::GetBrowserDataL( MStreamBuf& aSink )

    {

    if ( iColNoBrowserData != KDbNullColNo )

        {

        RDbColReadStream rs;

        rs.OpenLC( *this, iColNoBrowserData );

        RWriteStream ws( &aSink );

        rs.ReadL( ws );

        CleanupStack::PopAndDestroy();  // Close rs

        }

    }

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

// RFavouritesSrvTable::FactoryItem

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

//

TBool RFavouritesSrvTable::FactoryItem() const

    {

    return ColInt( iColNoFactoryItem );

    }

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

// RFavouritesSrvTable::ReadOnly

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

//

TBool RFavouritesSrvTable::ReadOnly() const

    {

    return ColInt( iColNoReadOnly );

    }

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

// RFavouritesSrvTable::ContextId

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

//

TInt32 RFavouritesSrvTable::ContextId() const

    {

    return ColInt32( iColNoContextId );

    }

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

// RFavouritesSrvTable::Modified

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

//

TTime RFavouritesSrvTable::Modified() const

    {

    TTime modified( 0 );

    if ( iColNoModified != KDbNullColNo )

        {

        modified = ColTime( iColNoModified );

        }

    return modified;

    }

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

// RFavouritesSrvTable::PreferredUid

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

//

TInt RFavouritesSrvTable::PreferredUid() const

    {

    TInt preferredUid( KFavouritesNullUid );

    if ( iColNoPreferredUid != KDbNullColNo )

        {

        preferredUid = ColInt( iColNoPreferredUid );

        }

    return preferredUid;

    }

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

// RFavouritesSrvTable::Hidden

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

//

TBool RFavouritesSrvTable::Hidden() const

    {

    return ColInt( iColNoHidden );

    }

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

// RFavouritesSrvTable::WriteItemDataL

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

//

void RFavouritesSrvTable::WriteItemDataL( const CFavouritesItemImpl& aItem )

    {

    // Fill standard attributes.

    __ASSERT_DEBUG( !ReadOnly(), FavouritesPanic( EFavouritesInternal ) );

    // Uid is *NOT* set. We update the current row.

    SetParentFolderL( aItem.ParentFolder() );

    SetTypeL( aItem.Type() );

    SetNameL( aItem.Name() );

    SetUrlL( aItem.Url() );

    SetUsernameL( aItem.UserName() );

    SetPasswordL( aItem.Password() );

    SetWapApL( aItem.WapAp() );

    // Note: read-only flag is *NOT* set. Setting that is accessible via

    // SetReadOnlyL.