/*

* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  The client side connection to the root-folder on the FeedsSever.

*

*/

#include "FeedsServerClient.h"

#include "FeedsServerFolderItem.h"

#include "FolderItemRequestHandlers.h"

#include "FeedRequestHandlers.h"

#include "ClientRequestHandlers.h"

#include "Logger.h"

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

// RFolderItem::RFolderItem

//

// C++ default constructor can NOT contain any code that

// might leave.

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

//

EXPORT_C RFolderItem::RFolderItem( MFolderItemObserver& aObserver, TInt aFolderListId, TBool aItemTitleNeed ):

        iObserver(aObserver), iFolderItem(NULL), iFolderListId(aFolderListId), iItemTitleNeed(aItemTitleNeed), 

        iFeedsServer( NULL )

    {

    CFolderItemRequestHandler *folderReqHandler = NULL;

    TRAP_IGNORE(

    {

    folderReqHandler =   CFolderItemRequestHandler::NewL();

    CleanupStack::PushL(folderReqHandler);

    iActiveRequests.AppendL(folderReqHandler);

    CleanupStack::Pop(folderReqHandler);

    });

    }

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

// RFolderItem::Open

//

// Opens a session to the given folder on the server.

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

//

EXPORT_C TInt RFolderItem::Open(RFeedsServer &aFeedsServer)

    {

    iFeedsServer = &aFeedsServer;

    RFeedsInterface *feedsInterface = iFeedsServer->iActiveRequests[0]->GetFeedInterface();

    iActiveRequests[0]->SetFeedInterface(feedsInterface);

    iFeedsServer->SetServerFolderItem(*this);

    return KErrNone;   

    }

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

// RFolderItem::Close

//

// Closes the connection to the server.

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

//

EXPORT_C void RFolderItem::Close()

    {    

    iFeedsServer = NULL;

    iActiveRequests.ResetAndDestroy();    

    delete iFolderItem;

    iFolderItem = NULL;

    }

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

// RFolderItem::RequestHandlerCompletedL

//

// Notifies the observer that the request is completed.

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

//

void RFolderItem::RequestHandlerCompletedL(CTransaction& aTrans, 

        TInt aStatus)

    {

    switch (aTrans.Type())

        {

        case CTransaction::EFetchRootFolderItem:

            if(aStatus == KErrNone)

               {

               delete iFolderItem;

               iFolderItem = NULL;

               iFolderItem = CFolderItem::NewL(iFolderListId, iActiveRequests[0]->GetFeedInterface()->RootFolder());

               // Notify the observer that the request has completed.

               iObserver.FolderItemRequestCompleted(aStatus, (CRequestHandler::TRequestHandlerType)aTrans.Type());

               }

            break;

        case CTransaction::EWatchForChanges:

            // Only notify the user if an error occurred.

            if (aStatus != KErrNone)

                {

                iObserver.FolderItemRequestCompleted(aStatus, (CRequestHandler::TRequestHandlerType)aTrans.Type());

                }

            break;

        // no need to notify observer now, server will notify us later

        // assuming FetchRootFolder or WatchFolderList has been called before

        case CTransaction::EAddFolderItem:

        case CTransaction::EDeleteFolderItem:

        case CTransaction::EChangeFolderItem:

        case CTransaction::EMoveFolderItem:

        case CTransaction::EMoveFolderItemTo:

        case CTransaction::EUpdateFolderItem:

        break;

        case CTransaction::EImportOPML:

        case CTransaction::EExportOPML:

            iObserver.FolderItemRequestCompleted(aStatus, (CRequestHandler::TRequestHandlerType)aTrans.Type());

            break;

        default:

            // Notify the observer that the request has completed.

            iObserver.FolderItemRequestCompleted(aStatus, (CRequestHandler::TRequestHandlerType)aTrans.Type());

            break;

        }

    }

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

// RFolderItem::NetworkConnectionNeededL()

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

//

void RFolderItem::NetworkConnectionNeededL( TInt* aConnectionPtr, TInt& aSockSvrHandle,

                                            TBool& aNewConn, TApBearerType& aBearerType )

    {

    iActiveRequests[0]->SetOperationRequested( EFalse);//reset the flag

    iObserver.NetworkConnectionNeededL( aConnectionPtr, aSockSvrHandle, aNewConn, aBearerType );

    }

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

// RFolderItem::FetchRootFolderItemL

//

// Fetches the root FolderItem.  FetchRootFolderItemCompleted is called upon completion.

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

//

EXPORT_C void RFolderItem::FetchRootFolderItemL()

    {

    iActiveRequests[0]->GetFeedInterface()->GetRootFolderL(); 

    }

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

// RFolderItem::AddFolderItemL

//

// Request the feeds server to add a new folder item.

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

//

EXPORT_C void RFolderItem::AddFolderItemL(const TDesC& aName, const TDesC& aUrl,

        TBool aIsFolder, const CFolderItem& aParent)

    {

    CFeedsMap* map = CFeedsMap::NewL();

    CleanupStack::PushL(map);

    map->SetStringAttribute(EFeedAttributeTitle, aName);

    map->SetStringAttribute(EFeedAttributeLink, aUrl);

    if(aIsFolder)

        {

        iActiveRequests[0]->GetFeedInterface()->AddL(EFolder, *map, *(aParent.iFeedsEntity));	

        }

    else

        {

        iActiveRequests[0]->GetFeedInterface()->AddL(EFeed, *map, *(aParent.iFeedsEntity)); 

        }

    CleanupStack::PopAndDestroy(map);

    }

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

// RFolderItem::ChangeFolderItemL

//

// Request the feeds server to change the folder item.  If this is a folder then

// KNullDesC should be passed to the aUrl argument.

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

//

EXPORT_C void RFolderItem::ChangeFolderItemL(const CFolderItem& aFolderItem, 

        const TDesC& aTitle, const TDesC& aUrl)

    {

    CFeedsMap* map = CFeedsMap::NewL();

    map->SetStringAttribute(EFeedAttributeTitle,aTitle);

    map->SetStringAttribute(EFeedAttributeLink,aUrl);

    iActiveRequests[0]->GetFeedInterface()->SetAttributeL(*(aFolderItem.iFeedsEntity), *map);

    delete map;

    }

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

// RFolderItem::DeleteFolderItemsL

//

// Request the feeds server to delete the folder items.

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

//

EXPORT_C void RFolderItem::DeleteFolderItemsL(RPointerArray<const CFolderItem>& 

        aFolderItems)

    {

    RPointerArray<const CFeedsEntity> feedsEntities;

    CleanupClosePushL(feedsEntities);

    for(TInt index = 0; index <aFolderItems.Count(); index ++)

        {

        feedsEntities.Append(aFolderItems[index]->iFeedsEntity);

        }

    iActiveRequests[0]->GetFeedInterface()->DeleteL(feedsEntities);

    // Clean up

    CleanupStack::PopAndDestroy(/*feedsEntities*/);

    }

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

// RFolderItem::ExportFolderItemsL

//

// Request the feeds server to export the folder items.

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

//

EXPORT_C void RFolderItem::ExportFolderItemsL(RPointerArray<const CFolderItem>& 

        aFolderItems, const TDesC &aExportFileName)

    {

    if(aExportFileName.Length() <=0)

        {

        User::Leave(KErrArgument);

        }

    if(aFolderItems.Count() <=0)

        {

        User::Leave(KErrArgument);

        }

    RPointerArray<const CFeedsEntity> feedsEntities;

    CleanupClosePushL(feedsEntities);

    for(TInt index = 0; index <aFolderItems.Count(); index ++)

        {

        feedsEntities.Append(aFolderItems[index]->iFeedsEntity);

        }

    iActiveRequests[0]->GetFeedInterface()->ExportFoldersL(feedsEntities, aExportFileName);

    // Clean up

    CleanupStack::PopAndDestroy(/*feedsEntities*/);

    }

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

// RFolderItem::MoveFolderItemsToL

//

// Request the feeds server to move the folder items to a different parent. 

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

//

EXPORT_C void RFolderItem::MoveFolderItemsToL(RPointerArray<const CFolderItem>& 

        aFolderItems, const CFolderItem& aParent)

    {

    if (aFolderItems.Count() > 0)

        {        

        RPointerArray<const CFeedsEntity> feedsEntities;

        CleanupClosePushL(feedsEntities);

        for(TInt index = 0; index <aFolderItems.Count(); index ++)

           {

    	   feedsEntities.Append(aFolderItems[index]->iFeedsEntity);

           }

        iActiveRequests[0]->GetFeedInterface()->MoveToFolderL(feedsEntities, *(aParent.iFeedsEntity));

        // Clean up

        CleanupStack::PopAndDestroy(/*feedsEntities*/);

        }

    }

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

// RFolderItem::MoveFolderItemsL

//

// Request the feeds server to move the folder items to a different index. 

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

//

EXPORT_C void RFolderItem::MoveFolderItemsL(RPointerArray<const CFolderItem>& 

        aFolderItems, TInt aIndex)

    {

    if (aFolderItems.Count() > 0)

        {        

        RPointerArray<const CFeedsEntity> feedsEntities;

        CleanupClosePushL(feedsEntities);

        for(TInt index = 0; index <aFolderItems.Count(); index ++)

           {

    	   feedsEntities.Append(aFolderItems[index]->iFeedsEntity);

           }

        iActiveRequests[0]->GetFeedInterface()->MoveL(feedsEntities, aIndex);

        // Clean up

        CleanupStack::PopAndDestroy(/*feedsEntities*/);

       }

    }

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

// RFolderItem::UpdateFolderItemsL

//

// Request the feeds server to update the folder items (refresh them from the web). 

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

//

EXPORT_C void RFolderItem::UpdateFolderItemsL(const RPointerArray<const CFolderItem>& 

        aFolderItems)

    {

        if (aFolderItems.Count() > 0)

        {  

        iActiveRequests[0]->SetOperationRequested( ETrue);

        RPointerArray<const CFeedsEntity> feedsEntities;

        CleanupClosePushL(feedsEntities);

        for(TInt index = 0; index <aFolderItems.Count(); index ++)

           {

    	   feedsEntities.Append(aFolderItems[index]->iFeedsEntity);

           }

        iActiveRequests[0]->GetFeedInterface()->UpdateL(feedsEntities);

        // Clean up

        CleanupStack::PopAndDestroy(/*feedsEntities*/);

        }

    }

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

// RFolderItem::UpdateAllL

//

// Request the feeds server to update all of the folder items (refresh them 

// from the web) associated with current given folder list.

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

//

EXPORT_C void RFolderItem::UpdateAllL()

    {

    RPointerArray<const CFeedsEntity> feedsEntities;

    CleanupClosePushL(feedsEntities);

    iActiveRequests[0]->SetOperationRequested( ETrue);

    feedsEntities.Append((iActiveRequests[0]->GetFeedInterface()->RootFolder()));

    iActiveRequests[0]->GetFeedInterface()->UpdateL(feedsEntities);

    // Clean up

    CleanupStack::PopAndDestroy(/*feedsEntities*/);

    }

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

// RFolderItem::WatchFolderListL

//

// Sets up a notifier to execute when the folder list changes.

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

//

EXPORT_C void RFolderItem::WatchFolderListL()

    {

    iActiveRequests[0]->GetFeedInterface()->WatchFolderListL();

    }

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

// RFolderItem::HasRootFolderItem

//

// Returns ETrue if it has an available root folder.

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

//

EXPORT_C TBool RFolderItem::HasRootFolderItem() const

    {

    return (iFolderItem != NULL);

    }

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

// RFolderItem::RootFolderItem

//

// Once fetched, it returns the CFolderItem.  This method panics the client if it is 

// called before the folder item is available.

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

//

EXPORT_C const CFolderItem& RFolderItem::RootFolderItem() const

    {

    return *iFolderItem;

    }

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

// RFolderItem::ImportOPMLL

//

// Import OPML file passed from the client.

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

//

EXPORT_C void RFolderItem::ImportOPMLL( const TDesC& aPath, TBool /*aClearFolderList=EFalse*/ )

    {

    iActiveRequests[0]->GetFeedInterface()->ImportOPMLL(aPath);

    }