/*

* Copyright (c) 2008 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 to central repository database.

*

*/

#include <centralrepository.h>

#include "cenrepdatabaseutil.h"

#include "cenrepdatabaselogger.h"

const TInt KNoEntryId = 0; // Not allowed ID for entries. Deleted rows

                           // are marked with KNoEntryId

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

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

// Constructor

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

//

CCenRepDatabaseUtil::CCenRepDatabaseUtil( TUint32 aStartKey,

                                      TUint32 aColIncrement,

                                      TUint32 aColMask,

                                      TUint32 aIdCounterKey,

                                      TInt aColCount )

    : iStartKey( aStartKey ),

      iColIncrement( aColIncrement ),

      iColMask( aColMask ),

      iIdCounterKey( aIdCounterKey ),

      iColCount( aColCount )

    {

    }

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

// 2nd phase constructor

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

//

void CCenRepDatabaseUtil::ConstructL( TUid aUid )

    {

    if( iColIncrement - 1 + iColMask != KMaxTUint )

        {

        User::Leave( KErrArgument );

        }

    iRepository = CRepository::NewL( aUid );

    // Create semaphore name from repository uid

    TUidName uidName = aUid.Name();

    TInt err = iSemaphore.OpenGlobal( uidName );

    if ( err != KErrNone )

        {

        User::LeaveIfError( iSemaphore.CreateGlobal( uidName, 1 ) );

        }

    }

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

// Constructor

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

//

EXPORT_C CCenRepDatabaseUtil* CCenRepDatabaseUtil::NewL( TUid aUid, 

                                                     TUint32 aStartKey, 

                                                     TUint32 aColIncrement, 

                                                     TUint32 aColMask,

                                                     TUint32 aIdCounterKey,

                                                     TInt aColCount )

    {

    CENREPDATABASELOG( "CCenRepDatabaseUtil::NewL - IN" );

    CCenRepDatabaseUtil* self = CCenRepDatabaseUtil::NewLC( 

                                                        aUid, 

                                                        aStartKey, 

                                                        aColIncrement, 

                                                        aColMask, 

                                                        aIdCounterKey, 

                                                        aColCount );

    CleanupStack::Pop( self );

    CENREPDATABASELOG( "CCenRepDatabaseUtil::NewL - OUT" );

    return self;

    }

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

// Constructor

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

//

EXPORT_C CCenRepDatabaseUtil* CCenRepDatabaseUtil::NewLC( TUid aUid, 

                                                      TUint32 aStartKey, 

                                                      TUint32 aColIncrement, 

                                                      TUint32 aColMask,

                                                      TUint32 aIdCounterKey,

                                                      TInt aColCount )

    {

    CENREPDATABASELOG( "CCenRepDatabaseUtil::NewLC - IN" );

    CCenRepDatabaseUtil* self = new( ELeave ) CCenRepDatabaseUtil( 

                                                                aStartKey,

                                                                aColIncrement,

                                                                aColMask,

                                                                aIdCounterKey,

                                                                aColCount );

    CleanupStack::PushL( self );

    self->ConstructL( aUid );

    CENREPDATABASELOG( "CCenRepDatabaseUtil::NewLC - OUT" );

    return self;

    }

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

// Destructor

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

//

EXPORT_C CCenRepDatabaseUtil::~CCenRepDatabaseUtil()

    {

    CENREPDATABASELOG( "CCenRepDatabaseUtil::~CCenRepDatabaseUtil - IN" );

    iSemaphore.Close();

    delete iRepository;

    CENREPDATABASELOG( "CCenRepDatabaseUtil::~CCenRepDatabaseUtil - OUT" );

    }

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

// Begins transaction in repository.

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

//

EXPORT_C void CCenRepDatabaseUtil::BeginTransactionL()

    {

    CENREPDATABASELOG( "CCenRepDatabaseUtil::BeginTransactionL - IN" );

    iSemaphore.Wait();

	TCleanupItem cleanup( CCenRepDatabaseUtil::ReleaseSemaphore, this );

	CleanupStack::PushL( cleanup );

    User::LeaveIfError( 

        iRepository->StartTransaction( CRepository::EReadWriteTransaction ) );

	iRepository->CleanupRollbackTransactionPushL(); // if leave happens,

	                                                // only roll back, no delete

	CENREPDATABASELOG( "CCenRepDatabaseUtil::BeginTransactionL - OUT" );                                                

    }

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

// Commits changes in repository.

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

//

EXPORT_C TInt CCenRepDatabaseUtil::CommitTransaction()

    {

    CENREPDATABASELOG( "CCenRepDatabaseUtil::CommitTransaction - IN" );

	TUint32 temp;

	TInt retval = iRepository->CommitTransaction( temp );

	iSemaphore.Signal();

	CleanupStack::Pop( 2 ); // semaphore and repository

	CENREPDATABASELOG( "CCenRepDatabaseUtil::CommitTransaction - OUT" );

    return retval;

    }

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

// Rollback changes in repository.

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

//

EXPORT_C void CCenRepDatabaseUtil::RollbackTransaction()

    {

    CENREPDATABASELOG( "CCenRepDatabaseUtil::RollbackTransaction - IN" );

	CleanupStack::Pop( 2 ); // rollback transaction item and semaphore

	iRepository->RollbackTransaction();

	iSemaphore.Signal();

	CENREPDATABASELOG( "CCenRepDatabaseUtil::RollbackTransaction - OUT" );

    }

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

// Add new entry to cenrep.

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

//

EXPORT_C void CCenRepDatabaseUtil::AddEntryL( 

    TInt& aEntryId,

    const RIpAppPropArray& aArray )

    {

    CENREPDATABASELOG( "CCenRepDatabaseUtil::AddEntryL - IN" );

    CreateEntryIdL( aEntryId );

    TUint32 idKey = GetNewIdKeyL();

    // Add entry Id

    SetOrCreateKeyL( idKey, aEntryId );

    UpdatePropertiesL( idKey, aArray );

    CENREPDATABASELOG( "CCenRepDatabaseUtil::AddEntryL - OUT" );

    }

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

// Find entry by ID.

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

//

EXPORT_C TInt CCenRepDatabaseUtil::FindEntryL( 

    TInt aEntryId,

    RIpAppPropArray& aArray )

    {

    CENREPDATABASELOG( "CCenRepDatabaseUtil::FindEntryL - IN" );

    RKeyArray keys;

    CleanupClosePushL( keys );

    // Find all rows where ID is aServiceId (entry row + each property row)

    TInt err = iRepository->FindEqL( iStartKey, iColMask, aEntryId, keys );

    TInt count = keys.Count();

    if ( KErrNone == err && count > 0 )

        {

        TUint32 idKey = keys[ 0 ];

        for ( TInt i = 1; i <= iColCount; i++ )

            {

            RBuf value;

            value.CreateL( KCenRepMaxDesLength );

            value.CleanupClosePushL();

            TUint32 propertyKey = idKey + i * iColIncrement;

            TInt errProperty = iRepository->Get( propertyKey, value );

            if( errProperty == KErrNone && value.Compare( KNullDesC ) != 0 )

                {

                CCenRepDatabaseProperty* property = CCenRepDatabaseProperty::NewLC();

                property->SetName( propertyKey - idKey + iStartKey );

                User::LeaveIfError( property->SetValue( value ) );

                User::LeaveIfError( aArray.Append( property ) );

                CleanupStack::Pop( property );

                }

            CleanupStack::PopAndDestroy( &value );

            }

        }

    CleanupStack::PopAndDestroy( &keys );

    CENREPDATABASELOG( "CCenRepDatabaseUtil::FindEntryL - OUT" );

    return err;

    }

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

// Update entry in cenrep.

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

//

EXPORT_C TInt CCenRepDatabaseUtil::UpdateEntryL( 

    TInt aEntryId, 

    const RIpAppPropArray& aArray )

    {

    CENREPDATABASELOG( "CCenRepDatabaseUtil::UpdateEntryL - IN" );

    RKeyArray keys;

    CleanupClosePushL( keys );

    // Find rows where ID is located

    TInt err = iRepository->FindEqL( iStartKey, iColMask, aEntryId, keys );

    TInt count = keys.Count();

    if ( KErrNone == err && count > 0 )

        {

        TUint32 idKey = keys[ 0 ];

        UpdatePropertiesL( idKey, aArray );

        }

    CleanupStack::PopAndDestroy( &keys );

    CENREPDATABASELOG( "CCenRepDatabaseUtil::UpdateEntryL - OUT" );

    return err;

    }

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

// Delete entry from cenrep.

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

//

EXPORT_C TInt CCenRepDatabaseUtil::DeleteEntryL( TInt aEntryId )

    {

    CENREPDATABASELOG( "CCenRepDatabaseUtil::DeleteEntryL - IN" );

    RKeyArray keys;

    CleanupClosePushL( keys );

    // Find all rows where ID is aServiceId (entry row + each property row)

    TInt err = iRepository->FindEqL( iStartKey, iColMask, aEntryId, keys );

    TInt count = keys.Count();

    if ( KErrNone == err && count > 0 )

        {

        TUint32 idKey = keys[ 0 ];

        SetOrCreateKeyL( idKey, KNoEntryId );

        for ( TInt i = 1; i <= iColCount; i++ )

            {

            TUint32 propertyKey = idKey + i * iColIncrement;

            SetOrCreateKeyL( propertyKey, KNullDesC );

            }

        }

    CleanupStack::PopAndDestroy( &keys );

    CENREPDATABASELOG( "CCenRepDatabaseUtil::DeleteEntryL - OUT" );

    return err;

    }

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

// Find property and its value by ID.

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

//

EXPORT_C TInt CCenRepDatabaseUtil::FindPropertyL( TInt aEntryId, 

                    TUint32 aPropertyName,

                    CCenRepDatabaseProperty& aProperty )

    {

    CENREPDATABASELOG( "CCenRepDatabaseUtil::FindPropertyL - IN" );

    RKeyArray keys;

    CleanupClosePushL( keys );

    TBool found = EFalse;

    // Find all rows where ID is aServiceId (entry row + each property row)

    TInt err = iRepository->FindEqL( iStartKey, iColMask, aEntryId, keys );

    TInt count = keys.Count();

    if ( KErrNone == err && count > 0 )

        {

        TUint32 idKey = keys[ 0 ];

        for ( TInt i = 1; i <= iColCount; i++ )

            {

            TUint32 propertyKey = idKey + i * iColIncrement;

            TUint32 propertyName = propertyKey - idKey + iStartKey;

            if( propertyName == aPropertyName )

                {

                RBuf value;

                value.CreateL( KCenRepMaxDesLength );

                value.CleanupClosePushL();

                err = iRepository->Get( propertyKey, value );

                if( err == KErrNone )

                    {

                    if( value.Compare( KNullDesC ) != 0 )

                        {

                        aProperty.SetName( propertyName );

                        User::LeaveIfError( aProperty.SetValue( value ) );

                        found = ETrue;

                        }

                    }

                CleanupStack::PopAndDestroy( &value );

                break;

                }

            }

        }

    if( found )

        {

        err = KErrNone;

        }

    else

        {

        if( err == KErrNone )

            {

            err = KErrNotFound;

            }

        }

    CleanupStack::PopAndDestroy( &keys );

    CENREPDATABASELOG( "CCenRepDatabaseUtil::FindPropertyL - OUT" );

    return err;

    }

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

// Adds or updates properties to/in cenrep.

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

//

EXPORT_C TInt CCenRepDatabaseUtil::AddOrUpdatePropertiesL( 

    TInt aEntryId, 

    const RIpAppPropArray& aArray )

    {

    CENREPDATABASELOG( "CCenRepDatabaseUtil::AddOrUpdatePropertiesL - IN" );

    TBool updatedOrCreated = EFalse;

    RKeyArray keys;

    CleanupClosePushL( keys );

    // Find row maching to given ID

    TInt err = iRepository->FindEqL( iStartKey, iColMask, aEntryId, keys );

    if ( KErrNone == err && keys.Count() > 0 )

        {

        TUint32 idKey = keys[ 0 ];

        TInt count = aArray.Count();

        HBufC* data = HBufC::NewLC( KCenRepMaxDesLength );

        TPtr ptr = data->Des();

        // Add properties one by one

        for( TInt i = 0; i < count; i++ )

            {

            CCenRepDatabaseProperty* property = aArray[i];

            TUint32 propertyName = property->GetName();

            TUint32 key = idKey - iStartKey + propertyName;

            TInt errProperty = iRepository->Get( key, ptr );

            if( errProperty || ( ptr != property->GetDesValue() ) )

                {

                updatedOrCreated = ETrue;

                SetOrCreateKeyL( key, property->GetDesValue() );

                }

            }

        CleanupStack::PopAndDestroy( data );

        }

    CleanupStack::PopAndDestroy( &keys );

    if( !err && !updatedOrCreated )

        {

        CENREPDATABASELOG( "CCenRepDatabaseUtil::AddOrUpdatePropertiesL - Not updated or created" );

        err = KErrCancel;

        }

    CENREPDATABASELOG( "CCenRepDatabaseUtil::AddOrUpdatePropertiesL - OUT" );

    return err;

    }

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

// Return count of entries in cenrep.

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

//

EXPORT_C TInt CCenRepDatabaseUtil::EntryCountL( TInt& aCount )

    {

    CENREPDATABASELOG( "CCenRepDatabaseUtil::EntryCountL - IN" );

    RKeyArray keys;

    CleanupClosePushL( keys );

    // Find all rows where ID not equals to KNoEntryId

    TInt err = iRepository->FindNeqL( iStartKey, iColMask, KNoEntryId, keys );

    TInt count = keys.Count();

    if ( KErrNone == err && count > 0 )

        {

        aCount = keys.Count();

        }

    else

        {

        aCount = 0;    

        }

    CleanupStack::PopAndDestroy( &keys );

    CENREPDATABASELOG( "CCenRepDatabaseUtil::EntryCountL - OUT" );

    return err;

    }

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

// Find all ids of entries in cenrep.

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

//

EXPORT_C TInt CCenRepDatabaseUtil::FindEntryIdsL( RArray<TInt>& aEntryIds )

    {

    CENREPDATABASELOG( "CCenRepDatabaseUtil::FindEntryIdsL - IN" );

    aEntryIds.Reset();

    RKeyArray keys;

    CleanupClosePushL( keys );

    // Find all entry rows from ID column. Deleted rows are not returned.

    TInt err = iRepository->FindNeqL( iStartKey, iColMask, KNoEntryId, keys );

    TInt count = keys.Count();

    if ( KErrNone == err && count > 0 )

        {

        for( TInt i = 0; i < count; i++ )

            {

            TUint32 key = keys[i];

            TInt entryId = 0;

            User::LeaveIfError( iRepository->Get( key, entryId ) );

            User::LeaveIfError( aEntryIds.Append( entryId ) );

            }

        }

    CleanupStack::PopAndDestroy( &keys );

    CENREPDATABASELOG( "CCenRepDatabaseUtil::FindEntryIdsL - OUT" );

    return err;

    }

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

// Delete given properties from entry.

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