/*

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

*

*/

// INCLUDE FILES

#include <SenServiceConnection.h> // framework IDs

#include <SenXmlElement.h> // check if this include is needed(?)

#include <SenXmlUtils.h>

// #include "SenDebug.h"

//#include "MSenIdentityManager.h"

#include "SenIdentityProvider.h"

// CONSTANTS

namespace

    {

    _LIT8(KDefaultIdentityAttributeName,    "default");

    _LIT8(KNewElementName,                  "IdentityProvider");

    _LIT8(KServiceID,                       "ServiceID");

//    _LIT8(KFakeIMEI8,                       "012345678901234");

    }

EXPORT_C CSenIdentityProvider::CSenIdentityProvider(

                                                TDescriptionClassType aType)

: CSenXmlServiceDescription(aType)

    {

    }

EXPORT_C const TDesC8& CSenIdentityProvider::NewElementName()

    {

    return KNewElementName();

    }

EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewL(

                                                    const TDesC8& aEndpoint)

    {

    CSenIdentityProvider* pNew = NewLC(aEndpoint);

    CleanupStack::Pop();

    return(pNew);

    }

EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewLC(

                                                    const TDesC8& aEndpoint)

    {

    CSenIdentityProvider* pNew =

        new (ELeave) CSenIdentityProvider(EIdentityProvider);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aEndpoint);

    return pNew;

    }

EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewL(

                                                    const TDesC8& aEndpoint,

                                                    const TDesC8& aContract )

    {

    CSenIdentityProvider* pNew = NewLC(aEndpoint, aContract);

    CleanupStack::Pop();

    return(pNew) ;

    }

EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewLC(

                                                    const TDesC8& aEndpoint,

                                                    const TDesC8& aContract )

    {

    CSenIdentityProvider* pNew =

        new (ELeave) CSenIdentityProvider(EIdentityProvider);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aEndpoint, aContract);

    return pNew;

    }

EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewL(

                                                    const TDesC8& aEndpoint,

                                                    const TDesC8& aContract,

                                                    const TDesC8& aProviderID)

    {

    CSenIdentityProvider* pNew = NewLC(aEndpoint, aContract, aProviderID);

    CleanupStack::Pop();

    return(pNew) ;

    }

EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewLC(

                                                    const TDesC8& aEndpoint,

                                                    const TDesC8& aContract,

                                                    const TDesC8& aProviderID)

    {

    CSenIdentityProvider* pNew =

        new (ELeave) CSenIdentityProvider(EIdentityProvider);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aEndpoint, aContract, aProviderID);

    return pNew;

    }

EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewL(

                                                    const TDesC8& aEndpoint,

                                                    const TDesC8& aContract,

                                                    const TDesC8& aProviderID,

                                                    const TDesC8& aServiceID)

    {

    CSenIdentityProvider* pNew = NewLC(aEndpoint, aContract,

                                        aProviderID, aServiceID);

    CleanupStack::Pop();

    return(pNew) ;

    }

EXPORT_C CSenIdentityProvider* CSenIdentityProvider::NewLC(

                                                    const TDesC8& aEndpoint,

                                                    const TDesC8& aContract,

                                                    const TDesC8& aProviderID,

                                                    const TDesC8& aServiceID)

    {

    CSenIdentityProvider* pNew =

        new (ELeave) CSenIdentityProvider(EIdentityProvider);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aEndpoint, aContract, aProviderID, aServiceID);

    return pNew;

    }

EXPORT_C void CSenIdentityProvider::ConstructL(const TDesC8& aEndpoint)

    {

    if(aEndpoint.Length()>0)

        {

        CSenXmlServiceDescription::ConstructL(aEndpoint, KSenIdpLibertyIdWsfAsContract);

        SetFrameworkIdL( KDefaultIdWsfFrameworkID );

        }

    else

        {

        CSenXmlServiceDescription::ConstructL();

        }

    }

EXPORT_C void CSenIdentityProvider::ConstructL( const TDesC8& aEndpoint,

                                                const TDesC8& aContract)

    {

    if(aContract.Length()>0)

        {

        CSenXmlServiceDescription::ConstructL(aEndpoint, aContract);

        }

    else

        {

        // Defaults to ID-WSF framework authentication service contract:

        // - "urn:liberty:as:2004-04".

        ConstructL(aEndpoint);

        }

    }

EXPORT_C void CSenIdentityProvider::ConstructL( const TDesC8& aEndpoint,

                                                const TDesC8& aContract,

                                                const TDesC8& aProviderID)

    {

    ConstructL(aEndpoint, aContract);

    if(aProviderID.Length()>0)

        {

        SetProviderID(aProviderID);

        }

    // else: no <ProviderID> child element will be added

    }

EXPORT_C void CSenIdentityProvider::ConstructL( const TDesC8& aEndpoint,

                                                const TDesC8& aContract,

                                                const TDesC8& aProviderID,

                                                const TDesC8& aServiceID)

    {

    ConstructL(aEndpoint, aContract, aProviderID);

    if(aServiceID.Length()>0)

        {

        SetServiceID(aServiceID);

        }

    // else: no <ServiceID> child element will be added

    }

//////////////////////////////////////////////////////////////////////////

EXPORT_C CSenIdentityProvider::~CSenIdentityProvider()

    {

    }

EXPORT_C TPtrC8 CSenIdentityProvider::UserName()

    {

    TPtrC8 username = AuthzID();

    if (username.Length()==0)

        {

        return AdvisoryAuthnID();

        }

    return username;

    }

EXPORT_C TPtrC8 CSenIdentityProvider::AuthzID()

    {

    return ContentOf( KSenIdpAuthzIDLocalname() );

    }

EXPORT_C TPtrC8 CSenIdentityProvider::AdvisoryAuthnID()

    {

    return ContentOf( KSenIdpAdvisoryAuthnIdLocalname() );

    }

EXPORT_C TPtrC8 CSenIdentityProvider::ProviderID()

    {

    return ContentOf( KSenIdpProviderIdLocalname() );

    }

EXPORT_C TPtrC8 CSenIdentityProvider::Password()

    {

    return ContentOf( KSenIdpPasswordLocalname() );

    }

EXPORT_C const TDesC8& CSenIdentityProvider::IMEI()

    {

    return KFakeIMEI8();

    }

EXPORT_C TBool CSenIdentityProvider::IsDefault()

    {

    TBool ret = EFalse;

    if ( AsElement().AttrValue( KDefaultIdentityAttributeName ) )

        {

        ret = ETrue;

        }

    return ret;

    }

//EXPORT_C TInt CSenIdentityProvider::SetUserInfo(const TDesC8& aAuthzID,

//                                                const TDesC8& aAdvisoryAuthnID,

//                                                const TDesC8& aPassword )

//    {

//    TInt leaveCode(KErrNone);

//    TRAP(leaveCode, SetUserInfoL(aAuthzID, aAdvisoryAuthnID, aPassword));

//    return leaveCode;

//    }

EXPORT_C TInt CSenIdentityProvider::SetUserInfoL(const TDesC8& aAuthzID,

                                                const TDesC8& aAdvisoryAuthnID,

                                                const TDesC8& aPassword )

    {

    // For MS this function sud be commented as WLM already send xml encoded password

    //HBufC8* encPassword = SenXmlUtils::EncodeHttpCharactersLC(aPassword);

    if(aAuthzID.Length()>0)

        {

        SetContentOfL(KSenIdpAuthzIDLocalname, aAuthzID);

        }

    if(aAdvisoryAuthnID.Length()>0)

        {

        SetContentOfL(KSenIdpAdvisoryAuthnIdLocalname, aAdvisoryAuthnID);

        }

    //if(aPassword.Length()>0) // in order to clean password, when listing accounts

        {

        SetContentOfL(KSenIdpPasswordLocalname, aPassword );

        }

    //CleanupStack::PopAndDestroy(encPassword);

    return KErrNone;

    }

EXPORT_C TInt CSenIdentityProvider::SetAccountExtensionsL(const TDesC8& aDetail)

    {

    SetContentOfL(KSenAccountExtensions, aDetail);

    //CSenElement* elem = NULL;

    //AddElementL(elem);

    return KErrNone;

    }

EXPORT_C TPtrC8 CSenIdentityProvider::AccountExtensions(CSenElement*& aAccExt)

    {

    aAccExt = this->AsElement().Element(KSenAccountExtensions());

    return ContentOf( KSenAccountExtensions() );

    }

EXPORT_C TBool CSenIdentityProvider::IsTrustedByL(

                        MSenServiceDescription& aServiceDescription )

    {

    TBool retVal(EFalse);

    TPtrC8 endpoint = aServiceDescription.Endpoint();

    TPtrC8 contract = aServiceDescription.Contract();

    TPtrC8 providerID = ProviderID();

    if(providerID.Length()>0)

        {

        if((endpoint.Length() > 0) && (providerID.Length() > 0)

                       && endpoint == providerID)

            {

            retVal = ETrue;

            }

        }

    if(!retVal) // no need to allocate new array etc if we already have a trust

        {

        // owned elsewhere:

        RPointerArray<CSenElement> services = AsElement().ElementsL();

        TInt serviceCount = services.Count();

        TInt i(0);

        while (!retVal && i < serviceCount)

            {

            if(services[i]->LocalName() == KServiceID)

                {

                TPtrC8 serviceID = services[i]->Content();

                if(serviceID.Length()>0 &&

                        ( (endpoint.Length() > 0 && serviceID == endpoint)

                                       ||

                          (contract.Length() > 0 && serviceID == contract))

                   )

                    {

                    retVal = ETrue;

                    }

                }

            i++;

            }

        }

    return retVal;

    }

EXPORT_C TBool CSenIdentityProvider::IsTrustedByL( const TDesC8& aProviderIdOrServiceId )

    {

    //SENDEBUG_L("CSenIdentityProvider::IsTrustedByL");

    TBool trusted(EFalse);

    TPtrC8 providerID = ProviderID();

    if(providerID.Length()>0)

        {

        if(aProviderIdOrServiceId == providerID)

            {

            //SENDEBUG_L("  The ProviderID's are equal.");

            trusted = ETrue;

            }

        }

    if(!trusted) // no need for new array etc if we already have a trust

        {

        RPointerArray<CSenElement> services = AsElement().ElementsL();

        TInt serviceCount = services.Count();

        TInt i(0);

        while (!trusted && i < serviceCount)

            {

            if (services[i]->LocalName() == KServiceID )

                {

                TPtrC8 serviceID = services[i]->Content();

                if (serviceID.Length()>0 && serviceID == aProviderIdOrServiceId)

                    {

                    trusted = ETrue;

                    }

                }

            i++;

            }

        }

    return trusted;

    }

EXPORT_C TInt CSenIdentityProvider::SetProviderID( const TDesC8& aProviderID )

    {

    TInt retVal(KErrNone);

    TInt leaveCode(KErrNone);

    TRAP( leaveCode, retVal = SetProviderIdL( aProviderID ); )

    if ( leaveCode )

        {

        retVal = leaveCode;

        }

    return retVal;

    }

EXPORT_C TInt CSenIdentityProvider::SetProviderIdL( const TDesC8& aProviderID )

    {

    if ( aProviderID.Length() == 0 )

        {

        return KErrArgument; // zero-length provider ID

        }

    else 

        {

        SetContentOfL( KSenIdpProviderIdLocalname, aProviderID );

        return KErrNone;

        }

    }

EXPORT_C TInt CSenIdentityProvider::SetServiceID( const TDesC8& aServiceID )

    {

    TInt retVal(KErrNone);

    if(aServiceID.Length()>0)

        {

        TRAP(retVal, SetContentOfL(KServiceID, aServiceID);)

        }

    return retVal;

    }

// @deprecated. This method is no longer in use. Kept only to keep BC with 3.0

EXPORT_C HBufC8* CSenIdentityProvider::HttpCredentialsL( MSenIdentityManager& /* aMgr */ )

    {

    return NULL;

    }

// End of File