/*

* 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:  ?Description

 *

*/

#include <s32mem.h>

#include <liwgenericparam.h>

#include <escapeutils.h>

#include <badesca.h>

#include "cpliwmap.h"

#include "cpdebug.h"

#include "cpssqlcommands.h"

#include "ccontentmap.h"

#include "cpublisherregistrymap.h"

#include "cpsecuritypolicy.h"

using namespace LIW;

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

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

// 

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

//

EXPORT_C CCPLiwMap* CCPLiwMap::NewL( RDesReadStream& aStream )

    {

    CLiwGenericParamList* list = CLiwGenericParamList::NewLC( aStream );

    CCPLiwMap* map = CCPLiwMap::NewL( *list );

    CleanupStack::PopAndDestroy( list );

    return map;

    }

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

// 

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

//

EXPORT_C CCPLiwMap* CCPLiwMap::NewL( const CLiwGenericParamList& aList )

    {

    CP_DEBUG( _L8("CCPLiwMap::NewL") );

    const TLiwGenericParam* param = NULL;

    TInt pos( 0 );

    param = aList.FindFirst( pos, KType );

    CCPLiwMap* map( NULL );

    if( param && pos !=KErrNotFound )

        {

        if( IsTypePublisherL(param->Value()) )

            {

            map = CPublisherRegistryMap::NewLC();

            }

        else 

            {

            map = CContentMap::NewLC();

            }

        map->SetL(aList);

        CleanupStack::Pop(map);

        }

    else

        {

        User::Leave( KErrPathNotFound );

        }

    return map;

    }

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

// 

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

//

EXPORT_C CCPLiwMap* CCPLiwMap::NewL( const CLiwMap& aMap )

    {

    CP_DEBUG( _L8("CCPLiwMap::NewL") );

    TLiwVariant typeVariant;

    typeVariant.PushL();

    CCPLiwMap* map( NULL );

    if (aMap.FindL(KType, typeVariant))

        {

        if( IsTypePublisherL(typeVariant) )

            {

            map = CPublisherRegistryMap::NewLC();

            }

        else 

            {

            map = CContentMap::NewLC();

            }

        map->SetL(aMap);

        CleanupStack::Pop(map);

        }

    else

        {

        User::Leave( KErrPathNotFound );

        }

    CleanupStack::PopAndDestroy(&typeVariant);

    return map;

    }

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

// 

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

//		

EXPORT_C HBufC8* CCPLiwMap::PackForServerLC() const

    {

    CP_DEBUG( _L8("CCPLiwMap::PackForServerLC") );

    HBufC8* datadesc = HBufC8::NewLC( Size() );

    TPtr8 ptr = datadesc->Des();

    RDesWriteStream datastrm( ptr );

    CleanupClosePushL(datastrm);

    ExternalizeL(datastrm);

    datastrm.CommitL();

    CleanupStack::PopAndDestroy(&datastrm);

    return datadesc;

    }

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

// 

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

//	

EXPORT_C void CCPLiwMap::Reset( ) const

    {

    iMap->Reset();    

    }

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

// 

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

//

void CCPLiwMap::IsValidForAddL( ) const

    {

    CP_DEBUG( _L8("CCPLiwMap::IsValidForAddL") );

    TInt err( KErrNone );

    TInt32 id( 0 );

    if( GetProperty( KId, id ) && ( id < 1 ) )

        {

        err = KErrArgument;

        }

    else if( !IsId() && PropertyExists( KId ) )

        {

        err = KErrBadName;

        }

    CheckIdentifiersL();

    if( err == KErrNone && !IsId() && !( IsPublisherNameL() 

            && IsContentTypeL() && IsContentIdL() ) )

        {

        err = KErrPathNotFound;

        }

    if( err != KErrNone )

        {

        User::Leave( err );

        }

    }

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

// 

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

//

EXPORT_C void CCPLiwMap::IsValidForActionL( )const

    {

    CP_DEBUG( _L8("CCPLiwMap::IsValidForActionL") );

    CCPLiwMap::IsValidForNotificationL();

    if( !IsTriggerL() ) User::Leave( KErrPathNotFound );

    }

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

// 

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

//

EXPORT_C void CCPLiwMap::IsValidForNotificationL( ) const

    {

    CP_DEBUG( _L8("CCPLiwMap::IsValidForAddL") );

    TInt err( KErrNone );

    TInt32 id( 0 );

    if( GetProperty( KId, id ) && ( id < 1 ) )

        {

        err = KErrArgument;

        }

    else if( !IsId() && PropertyExists( KId ) )

        {

        err = KErrBadName;

        }

    CheckIdentifiersL();

    if( err == KErrNone && !IsId() && !IsPublisherNameL() 

            && !IsContentTypeL() && !IsContentIdL() )

        {

        err = KErrPathNotFound;

        }

    if( err != KErrNone )

        {

        User::Leave( err );

        }

    }

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

// 

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

//

EXPORT_C TBool CCPLiwMap::GetPropertyL( const TDesC8& aProperty ,

        RBuf& aResult ) const

    {

    //change name

    CP_DEBUG( _L8("CCPLiwMap::GetProperty - TPtrC") );

    TBool result( EFalse );

    TInt pos( 0 );

    TPtrC result16( KNullDesC);

    TPtrC8 result8( KNullDesC8);

    const TLiwGenericParam* paramForValue = iMap->FindFirst( pos, aProperty );

    if ( pos != KErrNotFound )

        {

        if( paramForValue->Value().Get( result16 ) )

            {

            aResult.CreateL( result16 );

            result = ETrue;

            }

        else if( paramForValue->Value().Get( result8 ) )

            {

            aResult.Assign( EscapeUtils::ConvertToUnicodeFromUtf8L( result8 ) );

            result = ETrue;

            }

        else

        	{

        	User::Leave( KErrBadName );

        	}

        }

    return result;

    }

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

// 

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

//

EXPORT_C TBool CCPLiwMap::GetPropertyL( const TDesC8& aProperty ,

        RBuf8& aResult ) const

    {

    CP_DEBUG( _L8("CCPLiwMap::GetProperty - TPtrC8") );

    TBool result( EFalse );

    TInt pos( 0 );

    TPtrC8 result8( KNullDesC8 );

    TPtrC result16( KNullDesC );

    const TLiwGenericParam* paramForValue = iMap->FindFirst( pos, aProperty );

    if ( pos != KErrNotFound )

        {

        if( paramForValue->Value().Get( result8 ) )

            {

            aResult.CreateL( result8 );

            result = ETrue;

            }

        else if( paramForValue->Value().Get( result16 ) )

            {

            aResult.Assign( EscapeUtils::ConvertFromUnicodeToUtf8L( result16 ) );

            result = ETrue;

            }

        else

        	{

        	User::Leave( KErrBadName );

        	}

        }

    return result;

    }

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

// 

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

//

EXPORT_C TBool CCPLiwMap::GetProperty( const TDesC8& aProperty ,

		TInt32& aResult ) const

    {

    CP_DEBUG( _L8("CCPLiwMap::GetProperty - TInt32") );

    TBool result( EFalse );

    TInt pos( 0 );

    const TLiwGenericParam* paramForValue = iMap->FindFirst( pos, aProperty );

    if ( pos != KErrNotFound )

        {

        if( paramForValue->Value().Get( aResult ) )

            {

            result = ETrue;

            }

        }

    return result;

    }

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

// 

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

//

EXPORT_C CLiwDefaultList* CCPLiwMap::GetActionTriggersLC( ) const

    {

    CP_DEBUG( _L8("CCPLiwMap::GetActionTriggers") );

    TInt pos( 0 );

    CLiwDefaultList* list(NULL); 

    const TLiwGenericParam* paramForValue = iMap->FindFirst( pos, 

            KActionTrigger );

    if ( paramForValue )

        {

        if ( paramForValue->Value().TypeId() == EVariantTypeDesC8  )

            {

            list = CLiwDefaultList::NewLC();

            list->AppendL(paramForValue->Value());

            }

        if ( paramForValue->Value().TypeId() == EVariantTypeDesC  )

            {

            list = CLiwDefaultList::NewLC();

            RBuf8 desc8;

            desc8.CleanupClosePushL();

            desc8.Assign( EscapeUtils::ConvertFromUnicodeToUtf8L( 

                    paramForValue->Value().AsDes() ) );

            list->AppendL(TLiwVariant(desc8));

            CleanupStack::PopAndDestroy( &desc8 );

            }

        else if ( paramForValue->Value().TypeId() == EVariantTypeList )

            {

            list = CLiwDefaultList::NewLC();

            const CLiwList* sourceList = paramForValue->Value().AsList(); 

            TInt count = sourceList->Count();

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

                {

                TLiwVariant trigger;

                sourceList->AtL(i,trigger);

                if (trigger.TypeId() == EVariantTypeDesC8)

                    {

                    list->AppendL(trigger);

                    }

                else if (trigger.TypeId() == EVariantTypeDesC)

                    {

                    RBuf8 desc8;

                    desc8.CleanupClosePushL();

                    desc8.Assign( EscapeUtils::ConvertFromUnicodeToUtf8L( 

                            trigger.AsDes() ) );

                    list->AppendL(TLiwVariant(desc8));

                    CleanupStack::PopAndDestroy( &desc8 );

                    }

                }

            }

        }

    return list;

    }

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

// 

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

//

EXPORT_C void CCPLiwMap::SetSecurityL(  const RMessage2& aMessage )

    {

    delete iPolicy;

    iPolicy = NULL;    

    iPolicy = CCPSecurityPolicy::NewL( aMessage );

    }

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

// 

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

//

CCPLiwMap::~CCPLiwMap()

    {

    delete iMap;

    delete iPolicy;

    }

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

// 

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

//

CCPLiwMap::CCPLiwMap()

    {

    }

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

// 

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

//

void CCPLiwMap::InsertL( const TDesC8& aKey, const TLiwVariant& aValue )

    {

    CP_DEBUG( _L8("CCPLiwMap::InsertL") );

    Remove( aKey );

    TLiwGenericParam mp;

    mp.SetNameAndValueL( aKey, aValue );

    iMap->AppendL( mp );

    mp.Reset( );

    }

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

// 

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

//

TBool CCPLiwMap::FindL( const TDesC8& aKey, TLiwVariant& aValue ) const

    {

    CP_DEBUG( _L8("CCPLiwMap::FindL") );

    TInt pos = 0;

    TBool result(EFalse);

    const TLiwGenericParam* tempParam = iMap->FindFirst( pos, aKey );

    if ( tempParam )

        {

        aValue.SetL( tempParam->Value( ) );

        result = ETrue;

        }

    return result;

    }

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

// 

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

//

TInt CCPLiwMap::Count() const

    {

    return iMap->Count( );

    }

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

// 

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

//

TBool CCPLiwMap::AtL( TInt aIndex, TDes8& aKey ) const

    {

    CP_DEBUG( _L8("CCPLiwMap::AtL") );

    TBool result(EFalse);

    if ( 0 <= aIndex && aIndex < iMap->Count( ) )

        {

        aKey = ((*iMap)[aIndex]).Name( );

        result = ETrue;

        }

    return result;

    }

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

// 

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

//

void CCPLiwMap::Remove( const TDesC8& aKey )

    {

    CP_DEBUG( _L8("CCPLiwMap::Remove") );

    TInt pos = 0;

    iMap->FindFirst( pos, aKey );

    if ( pos != KErrNotFound )

        {

        iMap->Remove( aKey );

        }

    }

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

// 

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

//

TInt CCPLiwMap::Size() const

    {

    return iMap->Size( );

    }

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

// 

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

//	

void CCPLiwMap::ExternalizeL( RWriteStream& aStream ) const

    {

    CP_DEBUG( _L8("CCPLiwMap::ExternalizeL") );

    iMap->ExternalizeL( aStream );

    }

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

// 

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

//                  

void CCPLiwMap::FillChangeInfoMapL( RSqlStatement& aStmt, 

		CLiwDefaultMap* aMap )const

	{

    TInt idIndex = ColumnIndexL( aStmt, KColumnId );

    TInt publisherIndex = ColumnIndexL( aStmt, KColumnPublisher );

    TInt contentIndex = ColumnIndexL( aStmt, KColumnContent_type );

    TInt content_idIndex = ColumnIndexL( aStmt, KColumnContent_id );

    TInt acl_Index = ColumnIndexL( aStmt, KColumnAccessList );

    TInt32 id = aStmt.ColumnInt( idIndex ) ;

    TPtrC publisher;

    User::LeaveIfError(aStmt.ColumnText( publisherIndex,publisher) );

    TPtrC content_type;

    User::LeaveIfError(aStmt.ColumnText( contentIndex,content_type ) );

    TPtrC content_id;

    User::LeaveIfError(aStmt.ColumnText( content_idIndex,content_id) );

    aMap->InsertL( KId, TLiwVariant( id ) );

    aMap->InsertL( KPublisherId, TLiwVariant( publisher ) );

    aMap->InsertL( KContentType, TLiwVariant( content_type ) );

    aMap->InsertL( KContentId, TLiwVariant( content_id ) );

    aMap->InsertL( KOperation, TLiwVariant( KOperationDelete ) );

    RBuf type;

    type.CleanupClosePushL();

    if( GetPropertyL( KType, type ) )

         {

         aMap->InsertL( KType , TLiwVariant( type ) );

         }        

    CleanupStack::PopAndDestroy( &type );  

	}

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

// 

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

//

void CCPLiwMap::SetL( const CLiwGenericParamList& aInParamList )

    {

    CP_DEBUG( _L8("CCPLiwMap::SetL") );

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