/*

* Copyright (c) 2003-2005 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: 

* imps data util class.

*

*/

// INCLUDE FILES

#include    <e32base.h>

#include    <miutconv.h>

#include    "impskey.h"

#include    "impscdatautils.h"

#include    "impsdataaccessor.h"

#include    "impsgrouppropsint.h"

#include    "impsservices.h"

#include    "impsliterals.h"

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

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

// might leave.

//

TImpsCDataUtils::TImpsCDataUtils()

    {

    }

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

// TImpsCDataUtils::GetRecipientsL

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

void TImpsCDataUtils::GetRecipientsL(

    MImpsKey* aKey,

    MImpsDataAccessor* aAc,

    CPtrC16Array* aGroups,

    CPtrC16Array* aUsers,  

    CPtrC16Array* aSnGroups,      // ScreenName( GroupId )

    CPtrC16Array* aScreenNs )     // ScreenName( SName );

    {

    aKey->AddL( CREATEKEY( EImpsKeyRecipient, 0 ) );

    // Get User*:UserID

    TBool more(ETrue);

    TDesC* myPtr;

    TInt i = 0;         // aux index

    for ( i = 0; more; i++)

        {

        aKey->AddL( CREATEKEY( EImpsKeyUser, i ) );

        aKey->AddL( CREATEKEY( EImpsKeyUserID, 0 ) );

        if ( aAc->RestoreDescL( aKey, myPtr ) )

            {

            aUsers->AppendL( *myPtr );

            }

        else

            {

            more = EFalse;

            }

        aKey->PopL( 2 );

        }

    // get Group*:GroupID

    more = ETrue;

    for ( i = 0; more; i++)

        {

        aKey->AddL( CREATEKEY( EImpsKeyGroup, i ) );

        aKey->AddL( CREATEKEY( EImpsKeyGroupID, 0 ) );

        if ( aAc->RestoreDescL( aKey, myPtr ) )

            {

            aGroups->AppendL( *myPtr );

            }

        else

            {

            more = EFalse;

            }

        aKey->PopL( 2 );

        }

    // Group*:ScreenName

    more = ETrue;

    for ( i = 0; more; i++)

        {

        aKey->AddL( CREATEKEY( EImpsKeyGroup, i ) );

        aKey->AddL( CREATEKEY( EImpsKeyScreenName, 0 ) );

        aKey->AddL( CREATEKEY( EImpsKeySName, 0 ) );

        if ( aAc->RestoreDescL( aKey, myPtr ) )

            {

            aScreenNs->AppendL( *myPtr );

            aKey->ReplaceLastL( CREATEKEY( EImpsKeyGroupID, 0 ) );

            if ( aAc->RestoreDescL( aKey, myPtr ) )

                {

                aSnGroups->AppendL( *myPtr );

                } // else error in data!

            }

            {

            more = EFalse;

            }

        aKey->PopL( 3 );

        }

    aKey->PopL();

    // notice: no contact list supported yet 

    }

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

// TImpsCDataUtils::SetRecipientsL

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

void TImpsCDataUtils::SetRecipientsL(

    MImpsKey* aKey,

    MImpsDataAccessor* aAc,

    const MDesC16Array* aGroups,

    const MDesC16Array* aUserIds,  

    const MDesC16Array* aSnGroups,         // ScreenName( GroupId )

    const MDesC16Array* aScreenNames )     // ScreenName( SName );

    {

    aKey->AddL( CREATEKEY( EImpsKeyRecipient, 0 ) );

    TInt i = 0;

  // User recipients

    if ( aUserIds )

        {

        TInt count = aUserIds->MdcaCount();

        for ( i = 0; i < count; i++ )

            {            

            aKey->AddL( CREATEKEY( EImpsKeyUser, i ) );

            aKey->AddL( CREATEKEY( EImpsKeyUserID, 0 ) );

            aAc->StoreDescL( aKey, aUserIds->MdcaPoint( i ) );

            aKey->PopL( 2 );

            }

        } // userids

    if ( aGroups )

        {

        TInt count = aGroups->MdcaCount();

        for ( i = 0; i < count; i++ )

            {            

            aKey->AddL( CREATEKEY( EImpsKeyGroup, i ) );

            aKey->AddL( CREATEKEY( EImpsKeyGroupID, 0 ) );

            aAc->StoreDescL( aKey, aGroups->MdcaPoint( i ) );

            aKey->PopL( 2 );

            }          

        }  // groupid

    if ( aScreenNames )

        {

        TInt count = aScreenNames->MdcaCount();

        for ( i = 0; i < count; i++ )

            {            

            aKey->AddL( CREATEKEY( EImpsKeyGroup, i ) );

            aKey->AddL( CREATEKEY( EImpsKeyScreenName, 0 ) );

            aKey->AddL( CREATEKEY( EImpsKeySName, 0 ) );

            aAc->StoreDescL( aKey, aScreenNames->MdcaPoint( i ) );

            aKey->ReplaceLastL( CREATEKEY( EImpsKeyGroupID, 0 ) );

            // myAccess->StoreDescL( aKey, *aGroupId );

            aAc->StoreDescL( aKey, aSnGroups->MdcaPoint( i ) );

            aKey->PopL( 3 );

            }

        } // screenNames

    aKey->PopL();   // EImpsKeyRecipient

    }

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

// TImpsCDataUtils::SetSenderL

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

void TImpsCDataUtils::SetSenderL(

            MImpsKey* aKey,

            MImpsDataAccessor* aAc,

            const TDesC* aSender,

            const TDesC* aGroupId )

    {

    aKey->AddL( CREATEKEY( EImpsKeySender, 0 ) );

    if ( aSender && !aGroupId )

        {

        // Pure UserID

        aKey->AddL( CREATEKEY( EImpsKeyUser, 0 ) );

        aKey->AddL( CREATEKEY( EImpsKeyUserID, 0 ) );

        aAc->StoreDescL( aKey, *aSender );

        aKey->PopL( 2 );

        }

    else if ( aSender && aGroupId )

        {

        // Screen Name

        aKey->AddL( CREATEKEY( EImpsKeyGroup, 0 ) );

        aKey->AddL( CREATEKEY( EImpsKeyScreenName, 0 ) );

        aKey->AddL( CREATEKEY( EImpsKeySName, 0 ) );

        aAc->StoreDescL( aKey, *aSender );

        aKey->ReplaceLastL( CREATEKEY( EImpsKeyGroupID, 0 ) );

        aAc->StoreDescL( aKey, *aGroupId );

        aKey->PopL( 3 );

        }

    else if ( !aSender && aGroupId )

        {

        // Sender is Group, well ... maybe it is possible in principle

        aKey->AddL( CREATEKEY( EImpsKeyGroup, 0 ) );

        aKey->AddL( CREATEKEY( EImpsKeyGroupID, 0 ) );

        aAc->StoreDescL( aKey, *aGroupId );

        aKey->PopL( 2 );

        }

    aKey->PopL();

    }

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

// TImpsCDataUtils::GetUserListL

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

void TImpsCDataUtils::GetUserListL(

            MImpsKey* aPredecessor,

            MImpsDataAccessor* aAc,

            CDesCArray* aUsers,

            CDesCArray* aScreenNames )

    {

    // Get first the users

    TBool more(ETrue);

    TDesC* myPtr;

    TInt i = 0;         // aux index

    for ( i = 0; more; i++)

        {

        aPredecessor->AddL( CREATEKEY( EImpsKeyUser, i ) );

        aPredecessor->AddL( CREATEKEY( EImpsKeyUserID, 0 ) );

        if ( aAc->RestoreDescL( aPredecessor, myPtr ) )

            {

            aUsers->AppendL( *myPtr );

            }

        else

            {

            more = EFalse;

            }

        aPredecessor->PopL( 2 );

        }

    // Then get the screennames

    more = ETrue;

    for ( i = 0; more; i++)

        {

        aPredecessor->AddL( CREATEKEY( EImpsKeyScreenName, i ) );

        aPredecessor->AddL( CREATEKEY( EImpsKeySName, 0 ) );

        if ( aAc->RestoreDescL( aPredecessor, myPtr ) )

            {

            aScreenNames->AppendL( *myPtr );

            }

        else

            {

            more = EFalse;

            }

        aPredecessor->PopL( 2 );

        }

    }

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

// TImpsCDataUtils::GetUrlListL

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

void TImpsCDataUtils::GetUrlListL(

            MImpsDataAccessor* aAc,

            CDesCArray* aUrlList )

    {

    CImpsKey* myKey = CImpsKey::NewLC(); // << myKey

    TImpsDataUtils::AddValuesFromArrayL( 

        myKey, 

        KInviteUserRequestElements, 

        sizeof( KInviteUserRequestElements ) /

        sizeof( KInviteUserRequestElements[0] ) );

    myKey->AddL( CREATEKEY( EImpsKeyURLList, 0 ) );

    // Get the urls

    TBool more( ETrue );

    TDesC* myPtr;

    TInt i = 0;         // aux index

    for ( i = 0; more; i++)

        {

        myKey->AddL( CREATEKEY( EImpsKeyURL, i ) );

        if ( aAc->RestoreDescL( myKey, myPtr ) )

            {

            aUrlList->AppendL( *myPtr );

            }

        else

            {

            more = EFalse;

            }

        myKey->PopL( );

        }

    CleanupStack::PopAndDestroy();

    }

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

// TImpsCDataUtils::GetModAndAdmL

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

void TImpsCDataUtils::GetModAndAdmL(

            MImpsKey* aPredecessor,

            MImpsDataAccessor* aAc,

            CDesCArray* aModerators,

            CDesCArray* aAdmins )

    {

    // Get first the moderators

    TBool more(ETrue);

    TDesC* myPtr;

    TInt i = 0;         // aux index

    aPredecessor->AddL( CREATEKEY( EImpsKeyMod, 0 ) );

    aPredecessor->AddL( CREATEKEY( EImpsKeyUserList, 0 ) );

    for ( i = 0; more; i++)

        {

        aPredecessor->AddL( CREATEKEY( EImpsKeyUser, i ) );

        aPredecessor->AddL( CREATEKEY( EImpsKeyUserID, 0 ) );

        if ( aAc->RestoreDescL( aPredecessor, myPtr ) )

            {

            aModerators->AppendL( *myPtr );

            }

        else

            {

            more = EFalse;

            }

        aPredecessor->PopL( 2 );

        }

    aPredecessor->PopL( 2 );  // Pop out UserList,Pop out mod

    // Then get the admins

    aPredecessor->AddL( CREATEKEY( EImpsKeyAdmin, 0 ) );

    aPredecessor->AddL( CREATEKEY( EImpsKeyUserList, 0 ) );

    more = ETrue;

    for ( i = 0; more; i++)

        {

        aPredecessor->AddL( CREATEKEY( EImpsKeyUser, i ) );

        aPredecessor->AddL( CREATEKEY( EImpsKeyUserID, 0 ) );

        if ( aAc->RestoreDescL( aPredecessor, myPtr ) )

            {

            aAdmins->AppendL( *myPtr );

            }

        else

            {

            more = EFalse;

            }

        aPredecessor->PopL( 2 );

        }

    aPredecessor->PopL( 2 );  // Pop out UserList,out Admin

    }

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

// TImpsCDataUtils::GetUsersL

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

void TImpsCDataUtils::GetUsersL(

            MImpsKey* aPredecessor,

            MImpsDataAccessor* aAc,

            CDesCArray* aUsers )

    {

    // Get first the moderators

    TBool more(ETrue);

    TDesC* myPtr;

    TInt i = 0;         // aux index

    for ( i = 0; more; i++)

        {

        aPredecessor->AddL( CREATEKEY( EImpsKeyUser, i ) );

        aPredecessor->AddL( CREATEKEY( EImpsKeyUserID, 0 ) );

        if ( aAc->RestoreDescL( aPredecessor, myPtr ) )

            {

            aUsers->AppendL( *myPtr );

            }

        else

            {

            more = EFalse;

            }

        aPredecessor->PopL( 2 );

        }

    }

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

// TImpsCDataUtils::GetGroupPropertiesL

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

void TImpsCDataUtils::GetGroupPropertiesL(

            MImpsKey* aPredecessor,

            MImpsDataAccessor* aAc,

            CImpsCommonGroupPropsInt* aCommonP,

            CImpsPrivateGroupPropsInt* aPrivateP )

    {

    // Get first the common properties

    TBool more(ETrue);

    TDesC* myPtr;

    TInt i = 0;         // aux index

    aPredecessor->AddL( CREATEKEY( EImpsKeyGroupProperties, 0 ) );

    for ( i = 0; more; i++)

        {

        aPredecessor->AddL( CREATEKEY( EImpsKeyProperty, i ) );

        aPredecessor->AddL( CREATEKEY( EImpsKeyName, 0 ) );

        if ( aAc->RestoreDescL( aPredecessor, myPtr ) )

            {

            aPredecessor->PopL( ); // Pop out Name

            HBufC* newString = myPtr->AllocLC( );

            HBufC* mystring = newString;

            mystring->Des( ).UpperCase( );

            if( mystring->CompareF( KImpsName ) == 0 )

                {

                aPredecessor->AddL( CREATEKEY( EImpsKeyValue, 0 ) );

                if( aAc->RestoreDescL( aPredecessor, myPtr ) )

                    {

                    aCommonP->SetGroupNameL( *myPtr );

                    }

                aPredecessor->PopL( ); // Pop out Value

                }

            if( mystring->CompareF( KImpsAccessType ) == 0 )

                {

                aPredecessor->AddL( CREATEKEY( EImpsKeyValue, 0 ) );

                if( aAc->RestoreDescL( aPredecessor, myPtr ) )

                    {

                    HBufC* newString = myPtr->AllocLC( );

                    HBufC* mystring = newString;

                    mystring->Des( ).UpperCase( );

                    if( mystring->CompareF( KImpsOpen ) == 0 )

                        aCommonP->SetOpen( EImpsPropYes );

                    else

                        aCommonP->SetOpen( EImpsPropNo );

                    CleanupStack::PopAndDestroy(1);

                    }

                aPredecessor->PopL( ); // Pop out Value

                }

            if( mystring->CompareF( KImpsPrivateMessaging ) == 0 )

                {

                aPredecessor->AddL( CREATEKEY( EImpsKeyValue, 0 ) );

                if( aAc->RestoreDescL( aPredecessor, myPtr ) )

                    {

                    if( myPtr->CompareF( KImpsTrue ) == 0 )

                        aCommonP->SetPrivateAllowed( EImpsPropYes  );

                    else

                        aCommonP->SetPrivateAllowed( EImpsPropNo );

                    }

                aPredecessor->PopL( ); // Pop out Value

                }

            if( mystring->CompareF( KImpsType ) == 0 )

                {

                aPredecessor->AddL( CREATEKEY( EImpsKeyValue, 0 ) );

                if( aAc->RestoreDescL( aPredecessor, myPtr ) )

                    {

                    HBufC* newString = myPtr->AllocLC( );

                    HBufC* mystring = newString;

                    mystring->Des( ).UpperCase( );

                    if( mystring->CompareF( KImpsPublic ) == 0 )

                        aCommonP->SetPublic( EImpsPropYes  );

                    else

                        aCommonP->SetPublic( EImpsPropNo );

                    CleanupStack::PopAndDestroy(1);

                    }

                aPredecessor->PopL( ); // Pop out Value

                }

            if( mystring->CompareF( KImpsSearchable ) == 0 )

                {

                aPredecessor->AddL( CREATEKEY( EImpsKeyValue, 0 ) );

                if( aAc->RestoreDescL( aPredecessor, myPtr ) )

                    {

                    if( myPtr->CompareF( KImpsTrue ) == 0 )

                        aCommonP->SetSearchable( EImpsPropYes );

                    else

                        aCommonP->SetSearchable( EImpsPropNo );

                    }

                aPredecessor->PopL( ); // Pop out Value

                }

            if( mystring->CompareF( KImpsTopic ) == 0 )

                {

                aPredecessor->AddL( CREATEKEY( EImpsKeyValue, 0 ) );

                if( aAc->RestoreDescL( aPredecessor, myPtr ) )

                    {

                    aCommonP->SetTopicL( *myPtr );

                    }

                aPredecessor->PopL( ); // Pop out Value

                }

            if( mystring->CompareF( KImpsMaxActiveUsers ) == 0 )

                {

                aPredecessor->AddL( CREATEKEY( EImpsKeyValue, 0 ) );

                if( aAc->RestoreDescL( aPredecessor, myPtr ) )

                    {

                    TLex lex;

                    TUint32 myValue = 0;

                    lex.Assign( *myPtr );

                    lex.Val(myValue, EDecimal, 100000);

                    aCommonP->SetMaxNbrOfUsers( myValue );

                    }

                aPredecessor->PopL( ); // Pop out Value

                }

            if( mystring->CompareF( KImpsNumberOfUsers ) == 0 )

                {

                aPredecessor->AddL( CREATEKEY( EImpsKeyValue, 0 ) );

                if( aAc->RestoreDescL( aPredecessor, myPtr ) )

                    {

                    TLex lex;

                    TUint32 myValue = 0;

                    lex.Assign( *myPtr );

                    lex.Val(myValue, EDecimal, 100000);

                    aCommonP->SetNbrOfUsers( myValue );

                    }

                aPredecessor->PopL( ); // Pop out Value

                }

            // AutoDelete

            if( mystring->CompareF( KImpsAutoDelete ) == 0 )

                {

                aPredecessor->AddL( CREATEKEY( EImpsKeyValue, 0 ) );

                if( aAc->RestoreDescL( aPredecessor, myPtr ) )

                    {

                    if( myPtr->CompareF( KImpsTrue ) == 0 )

                        aCommonP->SetAutoDelete( EImpsPropYes );

                    else

                        aCommonP->SetAutoDelete( EImpsPropNo );

                    }

                aPredecessor->PopL( ); // Pop out Value

                }

            CleanupStack::PopAndDestroy(1);