/*
* 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 <liwcommon.h>

#include "ccontentmap.h"
#include "cpglobals.h"
#include "cpdebug.h"
#include "cpssqlcommands.h"
#include "cpsecuritypolicy.h"

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

CContentMap::CContentMap()
    {

    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CContentMap::ConstructL()
    {
    CCPLiwMap::ConstructL( );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CContentMap* CContentMap::NewL( )
    {
    CContentMap* self = CContentMap::NewLC( );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CContentMap* CContentMap::NewLC( )
    {
    CContentMap* self = new (ELeave) CContentMap();
    self->PushL();
    self->ConstructL( );
    return self;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CContentMap::~CContentMap()
    {
    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TInt32 CContentMap::AddL( RSqlDatabase aSqlDb,
    CLiwDefaultList* aNotificationList ) const
    {
    CP_DEBUG( _L8("CContentMap::AddL") );
    TInt32 id( 0);
    if ( !GetProperty( KId, id ) )
        {
        FetchIdL( aSqlDb, KSQLFetchId, id );
        }
    if ( id )
        {
        UpdateL( aSqlDb, id, aNotificationList );
        }
    else
        {
        id = AddToDbL( aSqlDb, aNotificationList );
        }
    return id;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TUint CContentMap::GetListL( RSqlDatabase aSqlDb,
    CLiwGenericParamList* aList, RArray<TInt32>& aItemsToDelete ) const
    {
    CP_DEBUG( _L8("CContentMap::GetListL") );
    aItemsToDelete.Reset( );
    return CCPLiwMap::GetListL( aSqlDb, KSQLGetList, aList, aItemsToDelete );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CContentMap::RemoveL( RSqlDatabase aSqlDb,
    CLiwDefaultList* aNotificationList ) const
    {
    CP_DEBUG( _L8("CContentMap::RemoveL") );
    //get ids of items to be deleted 
    GetIdsOfRemovedEntriesL( aSqlDb, KSQLGetIds, aNotificationList );
    CCPLiwMap::RemoveL( aSqlDb, KSQLDelete );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
void CContentMap::SaveQueryResultsL( RSqlStatement& aStmt,
    CLiwGenericParamList& aList, RArray<TInt32>& aItemsToDelete ) const
    {
    CP_DEBUG( _L8("CContentMap::SaveQueryResultsL") );
    TInt idIndex = ColumnIndexL( aStmt,  KColumnId );
    TInt publisherIndex = ColumnIndexL( aStmt,  KColumnPublisher );
    TInt contentIndex = ColumnIndexL( aStmt,  KColumnContent_type );
    TInt content_idIndex = ColumnIndexL( aStmt,  KColumnContent_id );
    TInt expiration_dateIndex = ColumnIndexL( aStmt,  KColumnExpiration_date );
    TInt acl_Index = ColumnIndexL( aStmt,  KColumnAccessList );
    TInt data_Index = ColumnIndexL( aStmt,  KColumnData );
    TInt action_Index = ColumnIndexL( aStmt,  KColumnAction );
    
    TBool aclCheckFailed( EFalse );
    while ( aStmt.Next( ) == KSqlAtRow )
        {
        TBool securityOk( EFalse );
        if( iPolicy )
            {
            TPtrC8 acl;
            User::LeaveIfError( aStmt.ColumnBinary( acl_Index, acl ) );
            securityOk = iPolicy->CheckSecurityL( acl , 
            		CCPSecurityPolicy::ERead );
            if ( !securityOk )
            	{
            	aclCheckFailed = ETrue;
            	}
            }
        if ( !iPolicy || securityOk )
            {
            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 ) );
            CLiwDefaultMap* targetMap = CLiwDefaultMap::NewLC( );
            targetMap->InsertL( KId, TLiwVariant( id ) );
            targetMap->InsertL( KPublisherId, TLiwVariant( publisher ) );
            targetMap->InsertL( KContentType, TLiwVariant(content_type ) );
            targetMap->InsertL( KContentId, TLiwVariant( content_id ) );

            TInt64 expiration_date;
            expiration_date = aStmt.ColumnInt64( expiration_dateIndex );
            if ( ( expiration_date )
            		&&(IsOutdated( TTime( expiration_date ) )) )
            	{
            	// add id of item to be deleted to aItemsToDelete array
            	// do not continue getlist operation
            	aItemsToDelete.AppendL( id );
            	}//if
            else
            	{
            	// continue getlist operation
            	TPtrC8 data;
            	User::LeaveIfError( aStmt.ColumnBinary( data_Index, data ) );
            	TPtrC8 action;
            	User::LeaveIfError( aStmt.ColumnBinary( action_Index, action ) );
            	if( data.Ptr() )
                    {
                    targetMap->InsertL( KDataMap , TLiwVariant( data ) );
                    }
                if( action.Ptr() )
                    {
                    targetMap->InsertL( KActionMap , TLiwVariant( action ) );
                    }
            	TLiwGenericParam result( KListMap, TLiwVariant( targetMap ));
            	aList.AppendL( result );
            	}//else        
            CleanupStack::PopAndDestroy( targetMap );
            }// if
        }//while
    //leave only if ACL security check for all items failed
	if ( aclCheckFailed && !aList.Count())
		{
		User::Leave( KErrPermissionDenied );
		}
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
void CContentMap::PrepareStmtforAddL( RSqlDatabase aSqlDb,
    RSqlStatement& aStmt, const TDesC& aQuery ) const
    {
    CP_DEBUG( _L8("CContentMap::PrepareStmtforAddL") );
    CCPLiwMap::PrepareStmtforAddL( aSqlDb, aStmt, aQuery );
    TTime expiration_date( NULL);
    GetExpirationDateL( expiration_date );
    TInt expiration_dateIndex = aStmt.ParameterIndex( KSQLExpiration_date );
    if ( expiration_dateIndex != KErrNotFound )
        {
        BindInt64L( aStmt, expiration_dateIndex, expiration_date.Int64() );
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
void CContentMap::PrepareStmtforUpdateL( RSqlDatabase aSqlDb,
    RSqlStatement& aStmt, TInt32 aId ) const
    {
    CP_DEBUG( _L8("CContentMap::PrepareStmtforUpdateL") );
    TTime expiration_date;
    TBool isExpirationDate = GetExpirationDateL( expiration_date );
    TBool isParameter(EFalse);
    RBuf query;
    query.CleanupClosePushL();
    query.CreateL( KSQLUpdate().Length( ) );
    query.Append( KSQLUpdate );
    RBuf8 data;
    data.CleanupClosePushL();
    RBuf8 action;
    action.CleanupClosePushL();
    if ( GetPropertyL( KDataMap, data ) )
        {
        query.ReAllocL( query.Length( ) + KSQLUpdateData().Length( ) );
        query.Append( KSQLUpdateData );
        isParameter = ETrue;
        }
    if ( GetPropertyL( KActionMap, action ) )
        {
        if ( isParameter )
            {
            query.ReAllocL( query.Length( ) + KComma().Length( ) );
            query.Append( KComma );
            }
        query.ReAllocL( query.Length( ) + KSQLUpdateAction().Length( ) );
        query.Append( KSQLUpdateAction );
        isParameter = ETrue;
        }
    if ( isExpirationDate )
        {
        if ( isParameter )
            {
            query.ReAllocL( query.Length( ) + KComma().Length( ) );
            query.Append( KComma );
            }
        query.ReAllocL( query.Length( ) + KSQLUpdateExpirationDate().Length( ) );
        query.Append( KSQLUpdateExpirationDate );
        isParameter = ETrue;
        }
    if ( !isParameter )  User::Leave( KErrPathNotFound );
    query.ReAllocL( query.Length( ) + KSQLUpdateWhere().Length( ) );
    query.Append( KSQLUpdateWhere );

    User::LeaveIfError( aStmt.Prepare( aSqlDb, query ) );
    TInt dataId = aStmt.ParameterIndex( KSQLId );
    BindIntL( aStmt, dataId, aId );

    if ( data.Length( ) )
        {
        TInt dataIndex = aStmt.ParameterIndex( KSQLData );
        BindBinaryL( aStmt, dataIndex, data );
        }
    if ( action.Length( ) )
        {
        TInt actionIndex = aStmt.ParameterIndex( KSQLAction );
        BindBinaryL( aStmt, actionIndex, action );
        }
    if ( isExpirationDate )
        {
        TInt expiration_dateIndex =
                aStmt.ParameterIndex( KSQLExpiration_date );
        BindInt64L( aStmt, expiration_dateIndex,
            expiration_date.Int64( ) );

        }
    CleanupStack::PopAndDestroy( &action );
    CleanupStack::PopAndDestroy( &data );
    CleanupStack::PopAndDestroy( &query );
    }
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
void CContentMap::UpdateL( RSqlDatabase aSqlDb, TInt32 aId,
    CLiwDefaultList* aNotificationList ) const
    {
    CP_DEBUG( _L8("CContentMap::UpdateL") );
    RSqlStatement stmt;
    CleanupClosePushL( stmt );
    CLiwDefaultMap* changeInfoMap = CLiwDefaultMap::NewLC( );
    FetchIdsL( aId, KSQLFetchIds, changeInfoMap, aSqlDb );
    if ( aNotificationList )
        {
        changeInfoMap->InsertL( KType, TLiwVariant( KCpData ) );
        aNotificationList->AppendL( TLiwVariant( changeInfoMap ) );
        }
    CleanupStack::PopAndDestroy( changeInfoMap );
    PrepareStmtforUpdateL( aSqlDb, stmt, aId );
    if ( stmt.Exec( ) <= 0 )
        {
        User::Leave( KErrNotFound );
        }
    CleanupStack::PopAndDestroy( &stmt );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
TInt32 CContentMap::AddToDbL( RSqlDatabase aSqlDb,
    CLiwDefaultList* aNotificationList ) const
    {
    CP_DEBUG( _L8("CContentMap::AddToDbL") );
    RSqlStatement stmt;
    CleanupClosePushL( stmt );
    PrepareStmtforAddL( aSqlDb, stmt, KSQLInsert );

    TInt dataIndex = stmt.ParameterIndex( KSQLData );
    TInt actionIndex = stmt.ParameterIndex( KSQLAction );
    TInt aclIndex = stmt.ParameterIndex( KSQLAccessList );
    
    RBuf8 data;
    data.CleanupClosePushL();
    GetPropertyL( KDataMap, data ) ;
    BindBinaryL( stmt, dataIndex, data );
    
    RBuf8 action;
    action.CleanupClosePushL();
    GetPropertyL( KActionMap, action ) ;    
    BindBinaryL( stmt, actionIndex, action );
    
    RBuf8 acl;
    acl.CleanupClosePushL();   
    if( !GetPropertyL( KAccessList , acl ) )
        {
        iPolicy->GetDefaultSecurityL( acl );
        }
    
    BindBinaryL( stmt, aclIndex, acl );
    if ( stmt.Exec( ) <= 0 )
        {
        User::Leave( KErrGeneral );
        }
        
    TSqlScalarFullSelectQuery id_query(aSqlDb);
    TInt32 ret( 0);
    ret = id_query.SelectIntL( KSQLGetLastInsertId );

    if ( aNotificationList )
        {
        RBuf publisher;
        publisher.CleanupClosePushL();   
        RBuf contentType;
        contentType.CleanupClosePushL();   
        RBuf contentId;
        contentId.CleanupClosePushL();   
        GetPropertyL( KPublisherId, publisher ) ;
        GetPropertyL( KContentType, contentType );
        GetPropertyL( KContentId, contentId );
        CLiwDefaultMap* changeInfoMap = CLiwDefaultMap::NewLC( );
        changeInfoMap->InsertL( KId, TLiwVariant( ret ) );
        changeInfoMap->InsertL( KType, TLiwVariant( KCpData ) );
        changeInfoMap->InsertL( KPublisherId, TLiwVariant( publisher ) );
        changeInfoMap->InsertL( KContentType, TLiwVariant( contentType ) );
        changeInfoMap->InsertL( KContentId, TLiwVariant( contentId ) );
        changeInfoMap->InsertL( KOperation, TLiwVariant( KOperationAdd ) );
        aNotificationList->AppendL( TLiwVariant( changeInfoMap ) );
        CleanupStack::PopAndDestroy( changeInfoMap ) ;
        CleanupStack::PopAndDestroy( &contentId ) ;
        CleanupStack::PopAndDestroy( &contentType ) ;
        CleanupStack::PopAndDestroy( &publisher ) ;
        }
    
    CleanupStack::PopAndDestroy( &acl ) ;
    CleanupStack::PopAndDestroy( &action ) ;
    CleanupStack::PopAndDestroy( &data ) ;
    CleanupStack::PopAndDestroy( &stmt ) ;
    return ret;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
// 
void CContentMap::AppendSortL( RBuf& aQuery, const TCPSortOrder& aSort ) const
    {
    CP_DEBUG( _L8("CContentMap::AppendSortL") );
    switch ( aSort )
        {
        case ECPPublisher:
            aQuery.ReAllocL( aQuery.Length( ) + KSQLOrderPublisher().Length( ) );
            aQuery.Append( KSQLOrderPublisher );
            break;
        case ECPContent:
            aQuery.ReAllocL( aQuery.Length( ) + KSQLOrderContent().Length( ) );
            aQuery.Append( KSQLOrderContent );
            break;
        default:
            aQuery.ReAllocL( aQuery.Length( ) + KSQLOrderRecent().Length( ) );
            aQuery.Append( KSQLOrderRecent );
            break;
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
TBool CContentMap::IsOutdated( const TTime aExpirationTime ) const
    {
    CP_DEBUG( _L8("CContentMap::IsOutdated") );
    TBool result(EFalse);
    TTime currentTime(0);
    currentTime.HomeTime( );
    if ( currentTime>aExpirationTime )
        {
        result = ETrue;
        }
    return result;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CContentMap::IsDataMapL() const
    {
    TInt pos( 0 );
    const TLiwGenericParam* paramForValue = iMap->FindFirst( pos, KDataMap );
    if ( pos != KErrNotFound )
        { 
        if( paramForValue->Value().TypeId() != LIW::EVariantTypeDesC8  )
            {
            User::Leave( KErrBadName );
            }
        }
    else
    	{
    	User::Leave( KErrPathNotFound );
    	}
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TBool CContentMap::GetExpirationDateL( TTime& aResult ) const
    {
    CP_DEBUG( _L8("CContentMap::GetExpirationDateL") );
    TInt pos( 0);
    TBool result(EFalse);
    const TLiwGenericParam* param= NULL;
    param = iMap->FindFirst( pos, KExpirationDate );
    if ( KErrNotFound != pos )
        {
        if ( !param->Value().Get( aResult ) )
            User::Leave( KErrArgument );
        result = ETrue;
        }
    return result;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CContentMap::IsValidForDeleteL() const
    {
    CP_DEBUG( _L8("CContentMap::IsValidFilterL") );
    TInt err( KErrNone );
    TInt32 id( 0 );
    if( GetProperty( KId, id ) && ( id < 1 ) )
        {
        err = KErrArgument;
        }
    else if( !IsId() && PropertyExists( KId ) )
        {
        err = KErrBadName;
        }
    
    if( err == KErrNone && !IsId( ) && !( IsPublisherNameL( ) 
            || IsContentTypeL( ) || IsContentIdL() ) )
        {
        err = KErrPathNotFound;
        }
    
    if( err != KErrNone )
        {
        User::Leave( err );
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CContentMap::IsValidForGetListL() const
    {
    CP_DEBUG( _L8("CContentMap::IsValidForGetListL") );
    TInt err( KErrNone );
    TInt32 id( 0 );
    if( GetProperty( KId, id ) && ( id < 1 ) )
        {
        err = KErrArgument;
        }
    else if( !IsId() && PropertyExists( KId ) )
        {
        err = KErrBadName;
        }
    
    if( err != KErrNone )
        {
        User::Leave( err );
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//                  
TBool CContentMap::ActivateActionSupport( ) const
    {
    return EFalse;
    }
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//                  
TBool CContentMap::GetActivateInfo( ) const
    {
    return EFalse;
    }