/*

* Copyright (c) 2002 - 2007 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:   ?Description

*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include <LiwServicehandler.h>

#include "landmarks_inputparams.h"

using namespace LIW;

_LIT(KLandmark, "Landmark" );

_LIT(KCategory, "Category" );

_LIT(KDatabase, "Database" );

_LIT(KMultiple, "Multiple" );

_LIT(KDefault, "Default" );

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

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

// Clandmarks_inputparams::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

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

//

void Clandmarks_inputparams::Delete() 

    {

    iLandmarkIf->Close();

    CLiwCriteriaItem* crit = CLiwCriteriaItem::NewLC(1, _L8("IDataSource"), _L8("Service.Landmarks"));

    crit->SetServiceClass(TUid::Uid(KLiwClassBase));

    RCriteriaArray a;

    CleanupClosePushL(a);

    a.AppendL(crit);

    iServiceHandler->DetachL(a);

    CleanupStack::PopAndDestroy(&a);

    CleanupStack::PopAndDestroy(crit);

    delete iServiceHandler;

    }

void Clandmarks_inputparams::InitL()

{

    iServiceHandler = CLiwServiceHandler::NewL();

    CLiwGenericParamList& inList = iServiceHandler->InParamListL();

    CLiwGenericParamList& outList = iServiceHandler->OutParamListL();

    CLiwCriteriaItem* crit = CLiwCriteriaItem::NewLC(1, _L8("IDataSource"), _L8("Service.Landmarks"));

    crit->SetServiceClass(TUid::Uid(KLiwClassBase));

    RCriteriaArray a;

    CleanupClosePushL(a);

    a.AppendL(crit);

    iServiceHandler->AttachL(a);

    iServiceHandler->ExecuteServiceCmdL(*crit,inList,outList);

    CleanupStack::PopAndDestroy(&a);

    CleanupStack::PopAndDestroy(crit);

    //retrieve the interface handle

    TInt index = 0;

    const TLiwGenericParam* outParam = outList.FindFirst(index,_L8("IDataSource")); 

    if( outParam )

        {

        iLandmarkIf = outParam->Value().AsInterface();

        }

    inList.Reset();

    outList.Reset();

}

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

// Clandmarks_inputparams::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt Clandmarks_inputparams::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function. 

        //ENTRY( "Example", Clandmarks_inputparams::ExampleL ),

        //ADD NEW ENTRY HERE

        // [test cases entries] - Do not remove

        ENTRY( "GetList", Clandmarks_inputparams::GetListL ),

        ENTRY( "Add", Clandmarks_inputparams::AddL ),

        ENTRY( "Delete", Clandmarks_inputparams::DeleteL ),

        ENTRY( "Import", Clandmarks_inputparams::ImportL ),

        ENTRY( "Export", Clandmarks_inputparams::ExportL ),

        ENTRY( "Organise", Clandmarks_inputparams::OrganiseL ),

        ENTRY( "Cancel", Clandmarks_inputparams::CancelL ),

        ENTRY( "Liw", Clandmarks_inputparams::LiwL ),

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// Clandmarks_inputparams::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt Clandmarks_inputparams::HandleNotifyL(

        TInt aCmdId,

        TInt aEventId,

        CLiwGenericParamList& aEventParamList,

        const CLiwGenericParamList& aInParamList)

    {

    return KErrNone;

    }

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

// Clandmarks_inputparams::ExampleL

// Example test method function.

// (other items were commented in a header).

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

//

TInt Clandmarks_inputparams::GetListL( CStifItemParser& aItem )

    {

    // Print to UI

    _LIT( Klandmarks_inputparams, "landmarks_inputparams" );

    _LIT( KExample, "In Example" );

    TestModuleIf().Printf( 0, Klandmarks_inputparams, KExample );

    // Print to log file

    iLog->Log( KExample );

    TInt i = 0;

    TOperation oper = NoOp;

    TType type = NoType;

    TPtrC string;

    _LIT( KParam, "Param[%i]: %S" );

    while ( aItem.GetNextString ( string ) == KErrNone )

        {

        TestModuleIf().Printf( i, Klandmarks_inputparams, 

                                KParam, i, &string );

        if( string == KMultiple )

        {

            oper = Multiple;

        }

        if( string == KDefault )

        {

            oper = Default;

        }

        if( string == KLandmark )

        {

            type = Landmark;

        }

        if( string == KCategory )

        {

            type = Category;

        }

        if( string == KDatabase )

        {

            type = Database;

        }

        i++;

        }

    TInt err = KErrGeneral;

    switch( oper )

    {

    case Default:

        {

            switch( type )

            {

            case Landmark: err = GetLandmarkDefL();

                           break;

            case Category: //err = GetCategoryDefL();

                           break;

            case Database: //err = GetDatabaseDefL();

                           break;

            }

        }

        break;

    default:

        {

            switch( type )

            {

            case Landmark: err = GetLandmarkL();

                           break;

            case Category: err = GetCategoryL();

                           break;

            case Database: err = GetDatabaseL();

                           break;

            }

        }

    }

    return err;

    }

TInt Clandmarks_inputparams::GetLandmarkL()

{

	//__UHEAP_MARK;

	InitL();

    CLiwGenericParamList& inList = iServiceHandler->InParamListL();

    CLiwGenericParamList& outList = iServiceHandler->OutParamListL();

    inList.Reset();

    outList.Reset();

    //Type mandatory

    inList.AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(_L("Landmark"))));

    //Filter Optional

    CLiwDefaultMap* filter = CLiwDefaultMap::NewL();

    CleanupStack::PushL(filter);

    filter->InsertL(_L8("DatabaseURI"),TLiwVariant(_L("c:eposlm.ldb")));

    filter->InsertL(_L8("MaximumMatches"),TLiwVariant((TInt32)10));

    filter->InsertL(_L8("PreviousMatchesOnly"),TLiwVariant((TBool)FALSE));

    filter->InsertL(_L8("LandmarkName"),TLiwVariant(_L("A*")));

    filter->InsertL(_L8("LandmarkDesc"),TLiwVariant(_L("D?")));

    CLiwDefaultMap* position = CLiwDefaultMap::NewL();

    CleanupStack::PushL(position);

    position->InsertL(_L8("Latitude"),TLiwVariant(14.23));

    position->InsertL(_L8("Longitude"),TLiwVariant(85.31));

    filter->InsertL(_L8("LandmarkPosition"),TLiwVariant(position));

    filter->InsertL(_L8("CoverageRadiusOption"),TLiwVariant((TBool)FALSE));

    filter->InsertL(_L8("CategoryName"),TLiwVariant(_L("Hotel")));

    CLiwDefaultMap* area = CLiwDefaultMap::NewL();

    CleanupStack::PushL(area);

    area->InsertL(_L8("NorthLatitude"),TLiwVariant(12.12));

    area->InsertL(_L8("SouthLatitude"),TLiwVariant(11.13));

    area->InsertL(_L8("EastLongitude"),TLiwVariant(14.14));

    area->InsertL(_L8("WestLongitude"),TLiwVariant(13.15));

    filter->InsertL(_L8("BoundedArea"),TLiwVariant(area));

    inList.AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(filter)));

    //Sort Optional

    CLiwDefaultMap* sort = CLiwDefaultMap::NewL();

    CleanupStack::PushL(sort);

    sort->InsertL(_L8("Key"),TLiwVariant(_L("LandmarkName")));

    sort->InsertL(_L8("Order"),TLiwVariant(_L("Ascending")));

    inList.AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(sort)));

    iLandmarkIf->ExecuteCmdL(_L8("getList"),inList,outList,0,0);  

    CleanupStack::Pop(sort);

    sort->DecRef();  

    CleanupStack::Pop(area);

    area->DecRef();

    CleanupStack::Pop(position);

    position->DecRef();  

    CleanupStack::Pop(filter);

    filter->DecRef();    

    TInt index = 0;

    const TLiwGenericParam* outParam = outList.FindFirst(index,_L8("ErrorCode")); 

    if( outParam )

        {

        index = outParam->Value().AsTInt32();

        }

    inList.Reset();

    outList.Reset();

    Delete();

    //__UHEAP_MARKEND;

    return index;

}

TInt Clandmarks_inputparams::GetLandmarkDefL()

{

    //__UHEAP_MARK;

    InitL();

    CLiwGenericParamList& inList = iServiceHandler->InParamListL();

    CLiwGenericParamList& outList = iServiceHandler->OutParamListL();

    inList.Reset();

    outList.Reset();

    //Type mandatory

    inList.AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(_L("Landmark"))));

    //Filter Optional

    CLiwDefaultMap* filter = CLiwDefaultMap::NewL();

    CleanupStack::PushL(filter);

    inList.AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(filter)));

    iLandmarkIf->ExecuteCmdL(_L8("GetList"),inList,outList,0,0);  

    CleanupStack::Pop(filter);

    filter->DecRef();

    TInt index = 0;

    const TLiwGenericParam* outParam = outList.FindFirst(index,_L8("ErrorCode")); 

    if( outParam )

        {

        index = outParam->Value().AsTInt32();

        }

    if( !index )

    {

        outParam = outList.FindFirst(index,_L8("ReturnValue")); 

        CLiwIterable* iter = outParam->Value().AsIterable();

        CheckAscending(Landmark,iter);

    }

    inList.Reset();

    outList.Reset();

    Delete();

    //__UHEAP_MARKEND;

    return index;

}

TInt Clandmarks_inputparams::GetCategoryL()

{

    //__UHEAP_MARK;

    InitL();

    CLiwGenericParamList& inList = iServiceHandler->InParamListL();

    CLiwGenericParamList& outList = iServiceHandler->OutParamListL();

    inList.Reset();

    outList.Reset();

    //Type mandatory

    inList.AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(_L("Category"))));

    //Filter Optional

    CLiwDefaultMap* filter = CLiwDefaultMap::NewL();

    CleanupStack::PushL(filter);

    filter->InsertL(_L8("DatabaseURI"),TLiwVariant(_L("c:eposlm.ldb")));

    filter->InsertL(_L8("MaximumMatches"),TLiwVariant((TInt32)10));

    filter->InsertL(_L8("PreviousMatchesOnly"),TLiwVariant((TBool)FALSE));

    filter->InsertL(_L8("CategoryName"),TLiwVariant(_L("A*")));

    inList.AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(filter)));

    //Sort Optional

    CLiwDefaultMap* sort = CLiwDefaultMap::NewL();

    CleanupStack::PushL(sort);

    sort->InsertL(_L8("Key"),TLiwVariant(_L("CategoryName")));

    sort->InsertL(_L8("Order"),TLiwVariant(_L("Ascending")));

    inList.AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(sort)));

    iLandmarkIf->ExecuteCmdL(_L8("GetList"),inList,outList,0,0);  

    CleanupStack::Pop(sort);

    sort->DecRef();

    CleanupStack::Pop(filter);

    filter->DecRef();

    TInt index = 0;

    const TLiwGenericParam* outParam = outList.FindFirst(index,_L8("ErrorCode")); 

    if( outParam )

        {

        index = outParam->Value().AsTInt32();

        }

    inList.Reset();

    outList.Reset();

    Delete();

    //__UHEAP_MARKEND;

    return index;

}

TInt Clandmarks_inputparams::GetDatabaseL()

{

    //__UHEAP_MARK;

    InitL();

    CLiwGenericParamList& inList = iServiceHandler->InParamListL();

    CLiwGenericParamList& outList = iServiceHandler->OutParamListL();

    inList.Reset();

    outList.Reset();

    ////__UHEAP_MARK;

    //Type mandatory

    inList.AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(_L("Database"))));

    //Filter Optional

    CLiwDefaultMap* filter = CLiwDefaultMap::NewL();

    CleanupStack::PushL(filter);

    filter->InsertL(_L8("DbProtocol"),TLiwVariant(_L("file")));

    inList.AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(filter)));

    //Sort Optional

    CLiwDefaultMap* sort = CLiwDefaultMap::NewL();

    CleanupStack::PushL(sort);

    sort->InsertL(_L8("Key"),TLiwVariant(_L("DatabaseURI")));

    sort->InsertL(_L8("Order"),TLiwVariant(_L("Ascending")));

    inList.AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(sort)));

    iLandmarkIf->ExecuteCmdL(_L8("GetList"),inList,outList,0,0);  

    CleanupStack::Pop(sort);

    sort->DecRef();

    CleanupStack::Pop(filter);

    filter->DecRef();

    TInt index = 0;

    const TLiwGenericParam* outParam = outList.FindFirst(index,_L8("ErrorCode")); 

    if( outParam )

        {

        index = outParam->Value().AsTInt32();

        }

    inList.Reset();

    outList.Reset();

    Delete();

    //__UHEAP_MARKEND;

    return index;

}

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

// Clandmarks_inputparams::ExampleL

// Example test method function.

// (other items were commented in a header).

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

//

TInt Clandmarks_inputparams::AddL( CStifItemParser& aItem )

    {

    // Print to UI

    _LIT( Klandmarks_inputparams, "landmarks_inputparams" );

    _LIT( KExample, "In Example" );

    TestModuleIf().Printf( 0, Klandmarks_inputparams, KExample );

    // Print to log file

    iLog->Log( KExample );

    TInt i = 0;

    TBool isMultiple = EFalse;

    TBool isLandmark = EFalse;

    TPtrC string;

    _LIT( KParam, "Param[%i]: %S" );

    while ( aItem.GetNextString ( string ) == KErrNone )

        {

        TestModuleIf().Printf( i, Klandmarks_inputparams, 

                                KParam, i, &string );

        if( string == KMultiple )

        {

            isMultiple = ETrue;

        }

        if( isMultiple && string == KLandmark )

        {

            isLandmark = ETrue;

        }

        i++;

        }

    TInt err = KErrGeneral;

    if( string == KLandmark )

    {

        err = AddLandmarkL();

    }

    if( string == KCategory )

    {

        err = AddCategoryL();

    }

    TInt32 count = 0;

    if( isMultiple )

    {

        TLex lexstring(string);

        lexstring.Val(count);

        if( isLandmark )

        {

            err = AddLmL(count);

        }

        else

        {

            err = AddCatL(count);

        }

    }

    return err;

    }

TInt Clandmarks_inputparams::AddLmL( TInt32 count )

{

    //__UHEAP_MARK;

    InitL();

    TInt err = KErrGeneral;

    while( count )

    {

    	err = KErrGeneral;

        CLiwGenericParamList& inList = iServiceHandler->InParamListL();

        CLiwGenericParamList& outList = iServiceHandler->OutParamListL();

        inList.Reset();

        outList.Reset();    

        //Type mandatory

        inList.AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(_L("Landmark"))));

        //Data mandatory

        CLiwDefaultMap* data = CLiwDefaultMap::NewL();

        CleanupStack::PushL(data);

        data->InsertL(_L8("DatabaseURI"),TLiwVariant(_L("c:eposlm.ldb")));