/*

* Copyright (c) 2006 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:   Implements CNcdOperationManager class

*

*/

#include "ncdoperationmanager.h"

#include <e32err.h>

#include <s32mem.h>

#include "ncdbaseoperation.h"

#include "ncdstoragemanager.h"

#include "ncdprotocol.h"

#include "catalogshttpsession.h"

#include "ncdnodemanager.h"

#include "catalogsbasemessage.h"

#include "ncdloadnodeoperationimpl.h"

#include "ncdloadrootnodeoperationimpl.h"

#include "ncdloadbundlenodeoperationimpl.h"

#include "ncdnodefunctionids.h"

#include "ncddownloadoperationimpl.h"

#include "ncdnodeidentifier.h"

#include "ncdproviderdefines.h"

#include "ncdstoragemanager.h"

#include "ncdpurchasehistorydbimpl.h"

#include "ncdconfigurationmanager.h"

#include "catalogssmssession.h"

#include "ncdpurchaseoperationimpl.h"

#include "ncdnodeimpl.h"

#include "ncdnodelink.h"

#include "catalogscontext.h"

#include "catalogshttpconfig.h"

#include "catalogsutils.h"

#include "ncdproviderimpl.h"

#include "ncdinstalloperationimpl.h"

#include "ncdchildloadmode.h"

#include "ncdrightsobjectoperationimpl.h"

#include "ncdutils.h"

#include "ncdsearchoperationimpl.h"

#include "ncdnodefolder.h"

#include "ncdsubscriptionoperationimpl.h"

#include "ncdsubscriptionmanagerimpl.h"

#include "ncdcontentdownloadoperation.h"

#include "ncdstorageclient.h"

#include "ncdstorage.h"

#include "ncdstorageitem.h"

#include "ncddatabasestorage.h"

#include "ncdnodemetadataimpl.h"

#include "ncdreportmanager.h"

#include "ncdcreateaccesspointoperationimpl.h"

#include "ncdsendhttprequestoperationimpl.h"

#include "ncdconnectionmethod.h"

#include "ncdserverreportoperationimpl.h"

#include "ncdoperationtype.h"

#include "ncdnodeidentifiereditor.h"

#include "ncderrors.h"

#include "ncdgeneralmanager.h"

#include "catalogsdebug.h"

// Because of security issues these capabilities are set for silent install

static _LIT_SECURITY_POLICY_C1( KSilentInstallInfoPolicy,

                                ECapabilityTrustedUI );

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

// NewL

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

//       

CNcdOperationManager* CNcdOperationManager::NewL( 

    CNcdProvider& aProvider,

    CNcdGeneralManager& aGeneralManager,    

    CNcdSubscriptionManager& aSubscriptionManager )

    {

    DLTRACEIN( ( "" ) );

    CNcdOperationManager* self = new( ELeave ) CNcdOperationManager(

        aProvider,

        aGeneralManager,          

        aSubscriptionManager );

    CleanupClosePushL( *self );

    self->ConstructL();

    CleanupStack::Pop( self );

    DLTRACEOUT( ( "" ) );

    return self;        

    }

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

// Destructor

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

//       

CNcdOperationManager::~CNcdOperationManager()

    {

    DLTRACEIN((""));

    // Should we destroy the operations here if operations

    // exist? operations should delete themselves when the operation

    // is finished? This class may implement some interface that

    // will be used to inform the manager when operation is

    // finished...

    // Close the cache array.

    DLTRACE(("Closing operations"));

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

        {        

        iOperationCache[i]->Close();

        }

    DLTRACE(("Operations closed"));

    iOperationCache.Reset();

    iOperationQueue.Close();

    DLTRACEOUT((""));

    }

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

// CreateOperationL

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

//       

void CNcdOperationManager::CreateLoadNodeOperationRequestL(

    MCatalogsBaseMessage& aMessage )

    {

    DLTRACEIN((""));

    // Get the session that will contain the handle of the node

    MCatalogsSession& requestSession( aMessage.Session() );

    DLTRACE(("create buffer"));

    RBuf8 buf;

    buf.CreateL( aMessage.InputLength() );

    DLINFO(("input length=%d",aMessage.InputLength()));

    CleanupClosePushL( buf );

    User::LeaveIfError( aMessage.ReadInput( buf ) );

    RDesReadStream stream( buf );

    CleanupReleasePushL( stream );

    DLTRACE(("get buffer data"));

    // Create node identifier from the stream    

    CNcdNodeIdentifier* identifier = CNcdNodeIdentifier::NewLC( 

        stream );

    if( ParallelOperationExistsForMetadataL( *identifier, aMessage.Session().Context() ) )

        {

        // Multiple simultaneous operations per one node are not supported, leave.

        User::Leave( KNcdErrorParallelOperationNotAllowed );

        }

    DLTRACE(("get load children flag"));

    TBool loadChildren = stream.ReadInt32L();

    DLTRACE(("get pageSize"));

    TInt pageSize = stream.ReadInt32L();

    DLTRACE(("get pageStart"));

    TInt pageStart = stream.ReadInt32L();

    DLTRACE(("get depth"));

    TInt depth = stream.ReadInt32L();

    DLTRACE(("get mode"));

    TNcdChildLoadMode mode = static_cast<TNcdChildLoadMode>(stream.ReadInt32L());

    DLTRACE(("get search flag"));

    TBool search = stream.ReadInt32L();

    CNcdSearchFilter* filter = NULL;

    if ( search )

        {

        DLTRACE(("get search filter"));

        filter = CNcdSearchFilter::NewLC();

        filter->SetContentPurposes( stream.ReadUint32L() );

        TInt keywordCount = stream.ReadInt32L();

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

            {

            HBufC* keyword = NULL;

            InternalizeDesL( keyword, stream );

            CleanupStack::PushL( keyword );

            filter->AddKeywordL( *keyword );

            CleanupStack::PopAndDestroy( keyword );

            }

        MNcdSearchFilter::TSearchMode mode;

        InternalizeEnumL( mode, stream );

        filter->SetSearchMode( mode );

        filter->SetRecursionDepthL( stream.ReadUint32L() );

        }

    DLTRACE(( _L("id, size, start, depth: %S, %d, %d, %d"),

              &identifier->NodeId(), pageSize, pageStart, depth ));

    CNcdNode& node = iNodeManager.NodeL( *identifier );

    DLTRACE(( _L("node found: %X"), &node ));

    TNcdResponseFilterParams filterParams;

    filterParams.iPageSize = pageSize;

    filterParams.iPageStart = pageStart;

    filterParams.iStructureDepth = depth;

    filterParams.iMetadataDepth = depth;

    filterParams.iMetadataPerLevel = pageSize;

    // create the operation

    CNcdLoadNodeOperationImpl* operation = NULL;

    if( search )

        {

        DLTRACE(("Create search op"));

        const CNcdNodeIdentifier* parentId = NULL;

        if ( node.ClassId() == NcdNodeClassIds::ENcdSearchItemNodeClassId ||

            node.ClassId() == NcdNodeClassIds::ENcdSearchFolderNodeClassId ||

            node.ClassId() == NcdNodeClassIds::ENcdSearchRootNodeClassId ||

            node.ClassId() == NcdNodeClassIds::ENcdSearchBundleNodeClassId )

            {

            DLTRACE(("search folder, use node's own parent"));

            parentId = &node.CreateAndSetLinkL().ParentIdentifier();

            }

        else

            {

            DLTRACE(("not a search folder, set search root as parent"));

            parentId = 

                &iNodeManager.CreateSearchRootL(aMessage.Session().Context()).Identifier();

            }

        // create op

        operation = CNcdSearchOperation::NewL(

            *identifier,

            *parentId,

            *filter,

            filterParams,

            iGeneralManager, 

            HttpSessionL( aMessage.Session().Context() ), 

            this, this, aMessage.Session(), loadChildren, mode,

            filter->RecursionDepth() );

        }

    else

        {

        DLTRACE(("Create load op"));

        CNcdNodeFactory::TNcdNodePurpose parentPurpose = CNcdNodeFactory::ENcdNormalNode;

        if ( !node.NodeLinkL().ParentIdentifier().ContainsEmptyFields() ) 

            {

            CNcdNode* parentNode = iNodeManager.NodePtrL( node.NodeLinkL().ParentIdentifier() );

            if ( parentNode )

                {                

                parentPurpose = CNcdNodeFactory::NodePurposeL( *parentNode );

                }

            }

        operation = CNcdLoadNodeOperationImpl::NewL(

            *identifier,

            node.NodeLinkL().ParentIdentifier(),

            parentPurpose,

            filterParams,

            iGeneralManager, 

            HttpSessionL( aMessage.Session().Context() ), 

            this, this, aMessage.Session(), loadChildren, mode, EFalse, EFalse );

        }

    DLTRACE(( _L("operation created: %X"), operation ));

    if( filter )

        {

        CleanupStack::PopAndDestroy( filter );

        }

    CleanupStack::PopAndDestroy( identifier );

    CleanupStack::PopAndDestroy( &stream );

    CleanupStack::PopAndDestroy( &buf );

    CleanupStack::PushL( operation );

    // Add the operation to the session and get the handle.

    // If the operation already existed in the session we will still

    // get a new handle to the same object.

    TInt32 operationHandle( requestSession.AddObjectL( operation ) );

    operation->SetHandle( operationHandle );

    // AddObjectL adds reference count by 1

    operation->Close();

    DLTRACE(("operation handle: %d", operationHandle ));

    // Because we created a new operation, it should be added to the

    // cache. 

    iOperationCache.AppendL( operation );

    CleanupStack::Pop( operation );    

    // Send the information to the client side

    TRAPD( error, 

           aMessage.CompleteAndReleaseL( operationHandle, KErrNone ) );

    if( error != KErrNone )

        {        

        iOperationCache.Remove( iOperationCache.Count() - 1 );

        // Is this ok?

        User::Leave( error );

        }

    }

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

// CreateOperationL

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

//       

void CNcdOperationManager::CreateLoadRootNodeOperationRequestL(

    MCatalogsBaseMessage& aMessage )

    {

    DLTRACEIN((""));

    // Get the session that will contain the handle of the node

    MCatalogsSession& requestSession( aMessage.Session() );

    RBuf8 nodeIdentifierData;

    nodeIdentifierData.CreateL( aMessage.InputLength() );

    CleanupClosePushL( nodeIdentifierData );

    User::LeaveIfError( aMessage.ReadInput( nodeIdentifierData ) );

    // Create node identifier from the stream    

    CNcdNodeIdentifier* identifier = CNcdNodeIdentifier::NewLC( 

        nodeIdentifierData );

    if( ParallelOperationExistsForMetadataL( *identifier, aMessage.Session().Context(),

            ETrue ) )

        {

        // Multiple simultaneous operations per one node are not supported, leave.

        User::Leave( KNcdErrorParallelOperationNotAllowed );

        }

    // create the operation

    CNcdLoadRootNodeOperation* operation = CNcdLoadRootNodeOperation::NewL(

        aMessage.Session().Context().FamilyId().iUid, 

        iGeneralManager, 

		HttpSessionL( aMessage.Session().Context() ), 

		this, 

		aMessage.Session() );

    CleanupStack::PopAndDestroy( identifier );

    CleanupStack::PopAndDestroy( &nodeIdentifierData );

    CleanupStack::PushL( operation );

    // Add the operation to the session and get the handle.

    // If the operation already existed in the session we will still

    // get a new handle to the same object.

    TInt32 operationHandle( requestSession.AddObjectL( operation ) );

    operation->SetHandle( operationHandle );

    operation->Close();

    DLTRACE(("operation handle: %d", operationHandle ));

    // Because we created a new operation, it should be added to the

    // cache. 

    iOperationCache.AppendL( operation );

    CleanupStack::Pop( operation );    

    // Send the information to the client side

    TRAPD( error, 

           aMessage.CompleteAndReleaseL( operationHandle, KErrNone ) );

    if( error != KErrNone )

        {        

        iOperationCache.Remove( iOperationCache.Count() - 1 );

        }

    } 

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

// CreateLoadBundleNodeOperationRequestL

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

//       

void CNcdOperationManager::CreateLoadBundleNodeOperationRequestL(

    MCatalogsBaseMessage& aMessage )

    {

    DLTRACEIN((""));

    // Get the session that will contain the handle of the node

    MCatalogsSession& requestSession( aMessage.Session() );

    RBuf8 nodeIdentifierData;

    nodeIdentifierData.CreateL( aMessage.InputLength() );

    CleanupClosePushL( nodeIdentifierData );

    User::LeaveIfError( aMessage.ReadInput( nodeIdentifierData ) );

    // Create node identifier from the stream    

    CNcdNodeIdentifier* identifier = CNcdNodeIdentifier::NewLC( 

        nodeIdentifierData );

    if( ParallelOperationExistsForMetadataL( *identifier, aMessage.Session().Context() ) )

        {

        // Multiple simultaneous operations per one node are not supported, leave.

        User::Leave( KNcdErrorParallelOperationNotAllowed );

        }

    // create the operation    

    CNcdLoadBundleNodeOperation* operation = CNcdLoadBundleNodeOperation::NewL(

        *identifier, 

        iGeneralManager, 

		HttpSessionL( aMessage.Session().Context() ), 

		this, 

		*this, 

		aMessage.Session() );

    CleanupStack::PopAndDestroy( identifier );

    CleanupStack::PopAndDestroy( &nodeIdentifierData );

    CleanupStack::PushL( operation );

    // Add the operation to the session and get the handle.

    // If the operation already existed in the session we will still

    // get a new handle to the same object.

    TInt32 operationHandle( requestSession.AddObjectL( operation ) );

    operation->SetHandle( operationHandle );

    operation->Close();

    DLTRACE(("operation handle: %d", operationHandle ));

    // Because we created a new operation, it should be added to the

    // cache. 

    iOperationCache.AppendL( operation );

    CleanupStack::Pop( operation );    

    // Send the information to the client side

    TRAPD( error, 

           aMessage.CompleteAndReleaseL( operationHandle, KErrNone ) );

    if( error != KErrNone )

        {        

        iOperationCache.Remove( iOperationCache.Count() - 1 );

        }

    } 

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

// CreateDownloadOperationL

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

//       

void CNcdOperationManager::CreateDownloadOperationRequestL(

    MCatalogsBaseMessage& aMessage )

    {

    DLTRACEIN((""));

    RCatalogsMessageReader reader;

    reader.OpenLC( aMessage );

    // Read operation type    

    TNcdDownloadDataType type = static_cast<TNcdDownloadDataType>( 

        reader().ReadInt32L() );

    DLINFO(( "Operation type: %d", type ));

    // Create node identifier from the stream    

    CNcdNodeIdentifier* identifier = CNcdNodeIdentifier::NewLC( 

        reader() );

    if( ParallelOperationExistsForMetadataL( *identifier, aMessage.Session().Context(),

        type == ENcdGenericFileDownload ) )

        {

        // Multiple simultaneous operations per one node are not supported, leave.

        User::Leave( KNcdErrorParallelOperationNotAllowed );

        }

    DLINFO(( _L("NodeId: %S::%S"), &identifier->NodeNameSpace(),

        &identifier->NodeId() ));

    // Read download index

    TInt downloadIndex = reader().ReadInt32L();

    DLINFO(( "Download index: %d", downloadIndex ));

    // Check if the download already exists, completes the message

    // if it does

    if ( DownloadExistsL( aMessage, *identifier, type, downloadIndex ) )

        {

        DLTRACE(("Download already exists"));

        CleanupStack::PopAndDestroy( 2, &reader ); // identifier, reader

        return;        

        }

    CleanupStack::Pop( identifier );

    CleanupStack::PopAndDestroy( &reader ); // reader

    CleanupStack::PushL( identifier );

    // Get current context

    MCatalogsContext& context( aMessage.Session().Context() );

    HBufC* clientUid = context.FamilyId().Name().AllocLC();    

    MNcdStorageClient* storageClient = NULL;

    // Generic file download doesn't use storage

    if ( type != ENcdGenericFileDownload ) 

        {

        // Quick fix: ensures that StorageManager has the client

        MNcdStorage* storage = StorageL( *clientUid, 

            identifier->NodeNameSpace() );

        // Find the correct storage for the client

        storageClient = 

            &iStorageManager.StorageClientL( *clientUid );

        }

    DLTRACE(("Creating the download operation"));

    // Try to get session handler

    MNcdSessionHandler* sessionHandler = NULL;

    TRAP_IGNORE(       

        sessionHandler = &iProtocolHandler.SessionHandlerL( context ) );

    CNcdBaseOperation* operation = NULL;

    if ( type != ENcdContentDownload ) 

        {        

        // Create operation according to it's type

        operation = CNcdDownloadOperation::NewL(

            *this,

            type,

            *identifier, 

            iGeneralManager,         

            HttpSessionL( context ),

            sessionHandler,

            storageClient,

            context.FamilyId(),