contentpublishingsrv/contentpublishingutils/contentpublishingmap/src/cpliwmap.cpp
/*
* 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++ )
{
const TLiwGenericParam& param = aInParamList[i];
ExtractParamL(param);
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::SetL( const CLiwMap& aMap )
{
CP_DEBUG( _L8("CCPLiwMap::SetL") );
for ( TInt i = 0; i < aMap.Count( ); i++ )
{
TBuf8<128> key;
aMap.AtL(i, key);
TLiwVariant value;
value.PushL();
aMap.FindL(key, value);
TLiwGenericParam param(key,value);
ExtractParamL(param);
CleanupStack::PopAndDestroy(&value);
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::ExtractParamL(const TLiwGenericParam& aParam)
{
CP_DEBUG( _L8("CCPLiwMap::ExtractVariantL") );
if (aParam.Value().TypeId() == LIW::EVariantTypeMap)
{
const CLiwMap* map = aParam.Value().AsMap();
for (TInt i = 0; i < map->Count(); i++)
{
TBuf8<128> key;
map->AtL(i, key);
TLiwVariant value;
value.PushL();
map->FindL(key, value);
if (key == KOperation)
{
IsProperOperationL(value);
}
RBuf8 datadesc;
datadesc.CleanupClosePushL();
if (value.TypeId() == LIW::EVariantTypeMap)
{
const CLiwMap* internalMap = value.AsMap();
datadesc.CreateL(internalMap->Size());
RDesWriteStream datastrm(datadesc);
CleanupClosePushL(datastrm);
internalMap->ExternalizeL(datastrm);
datastrm.CommitL();
CleanupStack::PopAndDestroy(&datastrm);
value.Reset();
value.Set(datadesc);
}
TLiwGenericParam data(key, value);
iMap->AppendL(data);
CleanupStack::PopAndDestroy(&datadesc);
CleanupStack::PopAndDestroy(&value);
}
}
else
{
iMap->AppendL(aParam);
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::IsProperOperationL( const TLiwVariant& aValue ) const
{
CP_DEBUG( _L8("CContentMap::IsProperOperationL") );
TPtrC valDesc( KNullDesC );
TPtrC8 valDesc8( KNullDesC8 );
RBuf desc;
desc.CleanupClosePushL();
if( aValue.Get( valDesc ) == EFalse )
{
if( aValue.Get( valDesc8 ) != EFalse )
{
desc.Assign( EscapeUtils::ConvertToUnicodeFromUtf8L( valDesc8 ) );
valDesc.Set( desc );
}
else
{
User::Leave( KErrBadName );
}
}
TLex input( valDesc );
CDesC16Array* array = new (ELeave) CDesC16ArrayFlat(4);
CleanupStack::PushL( array );
TLexMark startMark;
input.Mark( startMark );
TBool notEmpty = EFalse;
while ( !input.Eos() )
{
if( input.Peek() == ':')
{
array->AppendL( input.MarkedToken( startMark ) );
input.Inc();
input.Mark( startMark );
}
input.Inc();
notEmpty = ETrue;
}
if ( notEmpty )
{
array->AppendL( input.MarkedToken( startMark ) );
}
for( TInt i= 0; i < array->MdcaCount(); i++ )
{
TPtrC operValue( array->MdcaPoint(i) );
if( operValue.Compare( KOperationAdd ) &&
operValue.Compare( KOperationUpdate ) &&
operValue.Compare( KOperationDelete ) &&
operValue.Compare( KOperationExecute ) )
{
User::Leave( KErrArgument );
}
}
CleanupStack::PopAndDestroy( array );
CleanupStack::PopAndDestroy( &desc );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::AppendGetListFilterL( RBuf& aQuery, TUint& aFilter ) const
{
CP_DEBUG( _L8("CContentMap::AppendGetListFilterL") );
if( !IsGetListAllL( aFilter ) )
{
AppendFilterL( aQuery, aFilter );
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::AppendRemoveFilterL( RBuf& aQuery, TUint& aFilter ) const
{
CP_DEBUG( _L8("CContentMap::AppendRemoveFilterL") );
AppendFilterL( aQuery, aFilter );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::AppendFilterL( RBuf& aQuery, TUint& aFilter ) const
{
CP_DEBUG( _L8("CContentMap::AppendFilterL") );
TBool nextFilter( EFalse );
RemoveAllAttributeL( aFilter ); //remove "all" attribute from publisher,
//cont_type or cont_id
aQuery.ReAllocL( aQuery.Length( ) + KWhere().Length( ) );
aQuery.Append( KWhere );
if( aFilter & EContentType )
{
aQuery.ReAllocL( aQuery.Length( ) + KSQLGetContentType().Length( ) );
aQuery.Append( KSQLGetContentType );
nextFilter = ETrue;
}
if( aFilter & EPublisher )
{
if( nextFilter )
{
aQuery.ReAllocL( aQuery.Length( ) + KAnd().Length( ) +
KSQLGetPublisher().Length( ) );
aQuery.Append( KAnd );
aQuery.Append( KSQLGetPublisher );
}
else
{
aQuery.ReAllocL( aQuery.Length( ) +
KSQLGetPublisher().Length( ) );
aQuery.Append( KSQLGetPublisher );
}
nextFilter = ETrue;
}
if( aFilter & EContentId )
{
if( nextFilter )
{
aQuery.ReAllocL( aQuery.Length( ) +
KAnd().Length( ) + KSQLGetContentId().Length( ) );
aQuery.Append( KAnd );
aQuery.Append( KSQLGetContentId );
}
else
{
aQuery.ReAllocL( aQuery.Length( ) + KSQLGetContentId().Length( ) );
aQuery.Append( KSQLGetContentId );
}
nextFilter = ETrue;
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::PrepareStmtforAddL( RSqlDatabase aSqlDb,
RSqlStatement& aStmt, const TDesC& aQuery ) const
{
CP_DEBUG( _L8("CCPLiwMap::PrepareStmtforAddL") );
RBuf publisher;
publisher.CleanupClosePushL();
RBuf content_type;
content_type.CleanupClosePushL();
RBuf content_id;
content_id.CleanupClosePushL();
if ( GetPropertyL( KPublisherId, publisher )
&& GetPropertyL( KContentType, content_type )
&& GetPropertyL( KContentId, content_id ) )
{
User::LeaveIfError( aStmt.Prepare( aSqlDb, aQuery ) );
TInt publisherIndex = aStmt.ParameterIndex( KSQLPublisher );
TInt content_typeIndex = aStmt.ParameterIndex( KSQLContent_type );
TInt content_idIndex = aStmt.ParameterIndex( KSQLContent_id );
BindTextL( aStmt, publisherIndex, publisher );
BindTextL( aStmt, content_typeIndex, content_type );
BindTextL( aStmt, content_idIndex, content_id );
}
else
{
User::Leave( KErrArgument );
}
CleanupStack::PopAndDestroy( &content_id );
CleanupStack::PopAndDestroy( &content_type );
CleanupStack::PopAndDestroy( &publisher );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TUint CCPLiwMap::GetFilterL( )const
{
CP_DEBUG( _L8("CCPLiwMap::GetFilterL") );
TUint result (0);
if(IsPublisherNameL())
{
result |= EPublisher;
}
if(IsContentTypeL())
{
result |= EContentType;
}
if(IsContentIdL())
{
result |= EContentId;
}
if(IsFlag())
{
result |= EFlag;
}
return result;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CCPLiwMap::TCPSortOrder CCPLiwMap::GetSortL() const
{
CP_DEBUG( _L8("CCPLiwMap::GetSortL") );
TCPSortOrder result(ECPRecent);
RBuf sort;
sort.CleanupClosePushL();
if ( GetPropertyL( KSortOrder, sort ) )
{
if ( !sort.Compare( KSortRecent ) )
{
result = ECPRecent;
}
else if ( !sort.Compare( KSortPublisher ) )
{
result = ECPPublisher;
}
else if ( !sort.Compare( KSortContentType ) )
{
result = ECPContent;
}
else if ( !sort.Compare( KSortContentId ) )
{
result = ECPContentId;
}
}
CleanupStack::PopAndDestroy( &sort );
return result;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CCPLiwMap::IsPublisherNameL() const
{
return IsPropertyValidL( KPublisherId );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CCPLiwMap::IsContentTypeL() const
{
return IsPropertyValidL( KContentType );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CCPLiwMap::IsContentIdL() const
{
return IsPropertyValidL( KContentId );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CCPLiwMap::IsTriggerL( ) const
{
TBool result(EFalse);
TInt pos( 0 );
const TLiwGenericParam* paramForValue = iMap->FindFirst( pos,
KActionTrigger );
if ( pos != KErrNotFound )
{
result = ETrue;
LIW::TVariantTypeId variantType = paramForValue->Value().TypeId();
if ( variantType != EVariantTypeDesC &&
variantType != EVariantTypeDesC8 &&
variantType != EVariantTypeList )
{
User::Leave( KErrBadName );
}
}
return result;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CCPLiwMap::IsFlag( ) const
{
TInt32 buffer( 0 );
return GetProperty( KFlag, buffer );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CCPLiwMap::IsId() const
{
TInt32 id( 0);
return GetProperty( KId, id );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CCPLiwMap::PropertyExists( const TDesC8& aProperty ) const
{
TBool result( EFalse );
TInt pos( 0 );
const TLiwGenericParam* paramForValue = iMap->FindFirst( pos, aProperty );
if ( pos != KErrNotFound )
{
result = ETrue;
}
return result;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TUint CCPLiwMap::GetListL( RSqlDatabase aSqlDb, const TDesC& aQuery,
CLiwGenericParamList* aList, RArray<TInt32>& aItemsToDelete ) const
{
CP_DEBUG( _L8("CCPLiwMap::GetListL") );
RBuf sqlquery;
sqlquery.CleanupClosePushL();
sqlquery.CreateL( aQuery );
TInt32 id( 0);
if ( GetProperty( KId, id ) )
{
ConstructSelectIdL( sqlquery );
}
else
{
ConstructGetListSelectL( sqlquery );
}
RSqlStatement stmt;
CleanupClosePushL( stmt );
User::LeaveIfError( stmt.Prepare( aSqlDb, sqlquery ) );
BindValueL( sqlquery, stmt );
SaveQueryResultsL( stmt, *aList, aItemsToDelete );
CleanupStack::PopAndDestroy( &stmt ) ;
CleanupStack::PopAndDestroy( &sqlquery );
return aList->Count( );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::RemoveL( RSqlDatabase aSqlDb, const TDesC& aQuery ) const
{
CP_DEBUG( _L8("CCPLiwMap::RemoveL") );
RBuf sqlquery;
sqlquery.CleanupClosePushL();
sqlquery.CreateL( aQuery );
TInt32 id( 0);
if ( GetProperty( KId, id ) )
{
ConstructSelectIdL( sqlquery );
}
else
{
ConstructRemoveSelectL( sqlquery, EFalse );
}
RSqlStatement stmt;
CleanupClosePushL( stmt );
User::LeaveIfError( stmt.Prepare( aSqlDb, sqlquery ) );
BindValueL( sqlquery, stmt );
if ( stmt.Exec( ) <= 0 )
{
User::Leave( KErrNotFound );
}
CleanupStack::PopAndDestroy( &stmt ) ;
CleanupStack::PopAndDestroy( &sqlquery );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::FetchIdsL( TInt32 aId, const TDesC& aQuery,
CLiwDefaultMap* aMap, RSqlDatabase aSqlDb ) const
{
CP_DEBUG( _L8("CCPLiwMap::FetchIdsL") );
RSqlStatement stmt;
CleanupClosePushL( stmt );
//prepare statment for "Get Ids" (Publisher, ContentType,ContentId)
User::LeaveIfError( stmt.Prepare( aSqlDb, aQuery ) );
TInt idIndex = stmt.ParameterIndex( KSQLId );
User::LeaveIfError( stmt.BindInt( idIndex, aId ) );
TInt publisherIndex = ColumnIndexL( stmt, KColumnPublisher );
TInt contentTypeIndex = ColumnIndexL( stmt, KColumnContent_type );
TInt contentIdIndex = ColumnIndexL( stmt, KColumnContent_id );
TInt acl_Index = ColumnIndexL( stmt, KColumnAccessList );
if ( stmt.Next( ) == KSqlAtRow )
{
if( iPolicy )
{
TPtrC8 acl;
User::LeaveIfError( stmt.ColumnBinary( acl_Index, acl ) );
if( !iPolicy->CheckSecurityL( acl , CCPSecurityPolicy::EWrite ) )
{
User::Leave( KErrPermissionDenied );
}
}
TPtrC publisher;
User::LeaveIfError( stmt.ColumnText( publisherIndex, publisher ) );
TPtrC content_type;
User::LeaveIfError( stmt.ColumnText( contentTypeIndex, content_type ) );
TPtrC content_id;
User::LeaveIfError( stmt.ColumnText( contentIdIndex, content_id ) );
aMap->InsertL( KId, TLiwVariant( aId ) );
aMap->InsertL( KPublisherId, TLiwVariant( publisher ) );
aMap->InsertL( KContentType, TLiwVariant( content_type ) );
aMap->InsertL( KContentId, TLiwVariant( content_id ) );
aMap->InsertL( KOperation, TLiwVariant( KOperationUpdate ) );
}
CleanupStack::PopAndDestroy( &stmt ) ;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::FetchIdL( RSqlDatabase aSqlDb, const TDesC& aQuery,
TInt32& aId ) const
{
CP_DEBUG( _L8("CCPLiwMap::FetchIdL") );
aId = 0;
RSqlStatement stmt;
CleanupClosePushL( stmt );
PrepareStmtforAddL( aSqlDb, stmt, aQuery );
TInt idIndex = ColumnIndexL( stmt, KColumnId );
if ( stmt.Next( ) == KSqlAtRow )
{
aId = stmt.ColumnInt( idIndex );
}
CleanupStack::PopAndDestroy( &stmt ) ;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::GetIdsOfRemovedEntriesL( RSqlDatabase aSqlDb,
const TDesC& aQuery, CLiwDefaultList* aList ) const
{
CP_DEBUG( _L8("CCPLiwMap::GetIdsOfRemovedEntriesL") );
RBuf sqlquery;
sqlquery.CleanupClosePushL();
sqlquery.CreateL( aQuery );
TInt32 id( 0);
if ( GetProperty( KId, id ) )
{
ConstructSelectIdL( sqlquery );
}
else
{
ConstructRemoveSelectL( sqlquery );
}
RSqlStatement stmt;
CleanupClosePushL( stmt );
User::LeaveIfError( stmt.Prepare( aSqlDb, sqlquery ) );
BindValueL( sqlquery, stmt );
SaveQueryResultsIdsL( stmt, aList );
if( aList && aList->Count()==0 )
{
User::Leave( KErrNotFound );
}
CleanupStack::PopAndDestroy( &stmt ) ;
CleanupStack::PopAndDestroy( &sqlquery );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::SaveQueryResultsIdsL( RSqlStatement& aStmt,
CLiwDefaultList* aList ) const
{
CP_DEBUG( _L8("CCPLiwMap::SaveQueryResultsIdsL") );
TInt acl_Index = ColumnIndexL( aStmt, KColumnAccessList );
while ( aStmt.Next( ) == KSqlAtRow )
{
if( iPolicy )
{
TPtrC8 acl;
User::LeaveIfError( aStmt.ColumnBinary( acl_Index, acl ) );
if ( !iPolicy->CheckSecurityL( acl ,
CCPSecurityPolicy::EDelete ) )
{
User::Leave( KErrPermissionDenied );
}
}
if ( aList )
{
CLiwDefaultMap* targetMap = CLiwDefaultMap::NewLC( );
FillChangeInfoMapL( aStmt, targetMap );
aList->AppendL( TLiwVariant( targetMap ) );
CleanupStack::PopAndDestroy( targetMap );
}
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::ConstructSelectIdL( RBuf& aQuery ) const
{
aQuery.ReAllocL( aQuery.Length( ) + KSQLGetId().Length( ) +
KWhere().Length() );
aQuery.Append( KWhere );
aQuery.Append( KSQLGetId );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::ConstructGetListSelectL( RBuf& aQuery, TBool aGet ) const
{
TUint filter = GetFilterL( );
AppendGetListFilterL( aQuery, filter );
if ( aGet )
{
AppendSortL( aQuery, GetSortL( ) );
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::ConstructRemoveSelectL( RBuf& aQuery, TBool aGet ) const
{
TUint filter = GetFilterL( );
AppendRemoveFilterL( aQuery, filter );
if ( aGet )
{
AppendSortL( aQuery, GetSortL( ) );
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::BindValueL( const RBuf& aQuery, RSqlStatement& aStmt ) const
{
CP_DEBUG( _L8("CCPLiwMap::BindValueL") );
if ( aQuery.Find( KSQLGetPublisher ) != KErrNotFound )
{
TInt param = aStmt.ParameterIndex( KSQLPublisher );
RBuf publisher;
publisher.CleanupClosePushL();
User::LeaveIfError( GetPropertyL( KPublisherId, publisher ));
BindTextL( aStmt, param, publisher );
CleanupStack::PopAndDestroy( &publisher );
}
if ( aQuery.Find( KSQLGetContentType ) != KErrNotFound )
{
TInt param = aStmt.ParameterIndex( KSQLContent_type );
RBuf content_type;
content_type.CleanupClosePushL();
User::LeaveIfError( GetPropertyL( KContentType, content_type ));
BindTextL( aStmt, param, content_type );
CleanupStack::PopAndDestroy( &content_type );
}
if ( aQuery.Find( KSQLGetContentId ) != KErrNotFound )
{
TInt param = aStmt.ParameterIndex( KSQLContent_id );
RBuf content_id;
content_id.CleanupClosePushL();
User::LeaveIfError( GetPropertyL( KContentId, content_id ));
BindTextL( aStmt, param, content_id );
CleanupStack::PopAndDestroy( &content_id );
}
if ( aQuery.Find( KSQLGetId ) != KErrNotFound )
{
TInt param = aStmt.ParameterIndex( KSQLId );
TInt32 id( 0);
User::LeaveIfError( GetProperty( KId, id ));
BindIntL( aStmt, param, id );
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CCPLiwMap::IsGetListAllL( TUint aFilter ) const
{
TBool result( EFalse );
if ( !( aFilter & EContentType ) &&
!( aFilter & EContentId ) &&
!( aFilter & EPublisher ) )
{
result = ETrue;
}
else if ( ( aFilter & EContentType ) &&
( aFilter & EContentId ) &&
( aFilter & EPublisher ) )
{
RBuf publisher;
publisher.CleanupClosePushL();
RBuf content_type;
content_type.CleanupClosePushL();
RBuf content_id;
content_id.CleanupClosePushL();
GetPropertyL( KPublisherId, publisher );
GetPropertyL( KContentType, content_type );
GetPropertyL( KContentId, content_id );
if( ( publisher == KAll ) &&
( content_type == KAll ) &&
( content_id == KAll) )
{
result = ETrue;
}
CleanupStack::PopAndDestroy( &content_id );
CleanupStack::PopAndDestroy( &content_type );
CleanupStack::PopAndDestroy( &publisher );
}
return result;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::RemoveAllAttributeL( TUint& aFilter ) const
{
RBuf publisher;
publisher.CleanupClosePushL();
RBuf content_type;
content_type.CleanupClosePushL();
RBuf content_id;
content_id.CleanupClosePushL();
GetPropertyL( KPublisherId, publisher );
GetPropertyL( KContentType, content_type );
GetPropertyL( KContentId, content_id );
if( publisher == KAll )
{
iMap->Remove( KPublisherId );
aFilter = aFilter & ~EPublisher;
}
if( content_type == KAll )
{
iMap->Remove( KContentType );
aFilter = aFilter & ~EContentType;
}
if( content_id == KAll )
{
iMap->Remove( KContentId );
aFilter = aFilter & ~EContentId;
}
CleanupStack::PopAndDestroy( &content_id );
CleanupStack::PopAndDestroy( &content_type );
CleanupStack::PopAndDestroy( &publisher );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::ConstructL()
{
iMap = CLiwGenericParamList::NewL( );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CCPLiwMap::IsTypePublisherL( const TLiwVariant& aVariant )
{
TBool result (EFalse);
RBuf typeBuf;
typeBuf.CleanupClosePushL();
TPtrC type( KNullDesC );
if( !aVariant.Get( type ) )
{
TPtrC8 type8( KNullDesC8 );
if( !aVariant.Get( type8 ) )
{
User::Leave( KErrBadName );
}
typeBuf.Assign( EscapeUtils::ConvertToUnicodeFromUtf8L( type8 ) );
}
else
{
typeBuf.CreateL( type );
}
if( typeBuf.Find( KCpData () ) != KErrNotFound )
{
result = EFalse;
}
else if ( typeBuf.Find( KPublisher () ) != KErrNotFound )
{
result = ETrue;
}
else
{
User::Leave( KErrArgument );
}
CleanupStack::PopAndDestroy( &typeBuf );
return result;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::CheckIdentifiersL() const
{
IsPublisherNameL();
IsContentTypeL();
IsContentIdL();
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::BindTextL(RSqlStatement& aStmt, TInt aParameterIndex,
const TDesC& aParameterText) const
{
User::LeaveIfError( aParameterIndex );
User::LeaveIfError( aStmt.BindText( aParameterIndex, aParameterText ) );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::BindBinaryL(RSqlStatement& aStmt, TInt aParameterIndex,
const TDesC8& aParameterData) const
{
User::LeaveIfError(aParameterIndex);
User::LeaveIfError(aStmt.BindBinary(aParameterIndex, aParameterData));
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::BindInt64L(RSqlStatement& aStmt, TInt aParameterIndex,
TInt64 aParameterValue) const
{
User::LeaveIfError(aParameterIndex);
User::LeaveIfError(aStmt.BindInt64(aParameterIndex, aParameterValue));
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CCPLiwMap::BindIntL(RSqlStatement& aStmt, TInt aParameterIndex,
TInt aParameterValue) const
{
User::LeaveIfError(aParameterIndex);
User::LeaveIfError(aStmt.BindInt(aParameterIndex, aParameterValue));
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TInt CCPLiwMap::ColumnIndexL(RSqlStatement& aStmt, const TDesC& aColumnName )
const
{
TInt ret( aStmt.ColumnIndex( aColumnName ) );
User::LeaveIfError( ret );
return ret;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TBool CCPLiwMap::IsPropertyValidL( const TDesC8& aProperty ) const
{
CP_DEBUG( _L8("CCPLiwMap::IsPropertyValidL") );
TBool found( EFalse );
TInt pos( 0 );
const TLiwGenericParam* paramForValue = iMap->FindFirst( pos, aProperty );
if ( pos != KErrNotFound )
{
found = ETrue;
TInt length(0);
if( paramForValue->Value().TypeId() == EVariantTypeDesC )
{
length = paramForValue->Value().AsDes().Length();
}
else if ( paramForValue->Value().TypeId() == EVariantTypeDesC8 )
{
length = paramForValue->Value().AsData().Length();
}
else
{
User::Leave( KErrBadName );
}
if ( length == 0 )
{
User::Leave( KErrArgument );
}
}
return found;
}