/*

* 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 "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:  CXcapOmaPresRulesUsage

*

*/

#include <XdmErrors.h>

#include <XdmDocumentNode.h>

#include "XcapOmaPresRulesUsage.h"

// Used specification

// OMA-TS-Presence_SIMPLE_XDM-V1_0-20060110-C, 10 January 2006

// OMA-TS-Presence_SIMPLE_XDM-V1_0-20060418-C, 18 April 2006

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

// CXcapOmaPresRulesUsage::CXcapOmaPresRulesUsage

// 

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

//

CXcapOmaPresRulesUsage::CXcapOmaPresRulesUsage( const CXdmEngine& aXdmEngine ) :

CXcapAppUsage( aXdmEngine ),

iIetfPresRules( NULL ),

iIetfCommonPolicy( NULL ),

iOmaCommonPolicy( NULL )

    {

    }

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

// CXcapOmaPresRulesUsage::NewL

// 

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

//

CXcapOmaPresRulesUsage* CXcapOmaPresRulesUsage::NewL( const TXcapAppUsageParams& aParameters )

    {

    CXcapOmaPresRulesUsage* self = new ( ELeave ) CXcapOmaPresRulesUsage( aParameters.iXdmEngine );

    CleanupStack::PushL( self );	// << self

    self->ConstructL();

    CleanupStack::Pop( self );      // >> self

    return self;

    }

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

// CXcapOmaPresRulesUsage::~CXcapOmaPresRulesUsage

// 

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

//

CXcapOmaPresRulesUsage::~CXcapOmaPresRulesUsage()

    {

    delete iIetfPresRules;

    delete iIetfCommonPolicy;

    delete iOmaCommonPolicy;

    }

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

// CXcapOmaPresRulesUsage::ConstructL

// 

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

//

void CXcapOmaPresRulesUsage::ConstructL()

    {

    iIetfPresRules = CXcapAppUsage::NewL( iXdmEngine, KXdmIetfPresRulesUsageUid );

    iIetfCommonPolicy = CXcapAppUsage::NewL( iXdmEngine, KXdmIetfCommonPolicyUsageUid );

    iOmaCommonPolicy = CXcapAppUsage::NewL( iXdmEngine, KXdmOmaCommonPolicyUsageUid );

    }

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

// CXcapOmaPresRulesUsage::AUID

// 

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

//

TPtrC8 CXcapOmaPresRulesUsage::AUID() const

    {

    return TPtrC8( KXdmOmaPresRulesUsageAUID );

    }

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

// CXcapOmaPresRulesUsage::ContentType

// 

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

//

TPtrC8 CXcapOmaPresRulesUsage::ContentType() const

    {

    return TPtrC8( KXdmOmaPresRulesUsageContType );

    }

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

// CXcapOmaPresRulesUsage::DefaultNamespace

// 

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

//

TPtrC8 CXcapOmaPresRulesUsage::DefaultNamespace() const

    {

    //return TPtrC8( KXdmOmaPresRulesNamespace );

    // NOTE the default namespace is IetfCommonPolicy

    return TPtrC8( KXdmIetfCommonPolicyNamespace );

    }    

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

// CXcapOmaPresRulesUsage::ValidateL

// 

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

//

TBool CXcapOmaPresRulesUsage::ValidateNodeL( CXdmDocumentNode& aXdmNode )

    {

    // This method is called by base class for each element

    // in document, here we have to declare every element, check element 

    // datatype, restrictions for values and also do all checking that concerns  

    // the structure of the element. If the datatype is some of

    // the common datatypes defined in xcapappusage.h, the node

    // can pe passed to the base class for value validation.

    // If the node belongs to this namespace, the return value

    // should be true, false otherwise.

    TBool found ( EFalse );   

    TDataType dataType ( EDataTypeUndefined );

    TPtrC element = aXdmNode.NodeName();

    // <provide-willigness>

    if ( Match( element, KXdmProvideWillingness ) )

        {

        dataType = EDataTypeBoolean;

        found = ETrue;

        }

    // <provide-network-availability>

    else if ( Match( element, KXdmProvideNetworkAvailability ) )

        {

        dataType = EDataTypeBoolean;

        found = ETrue;

        }

    // <provide-session-participation>

    else if ( Match( element, KXdmProvideSessionParticipation ) )

        {

        dataType = EDataTypeBoolean;

        found = ETrue;

        }

    // <provide-registration-state>

    else if ( Match( element, KXdmProvideRegistrationState ) )

        {

        dataType = EDataTypeBoolean;

        found = ETrue;

        }

    // <provide-barring-state>

    else if ( Match( element, KXdmProvideBarringState ) )

        {

        dataType = EDataTypeBoolean;

        found = ETrue;

        }

    // <provide-geopriv>

    else if ( Match( element, KXdmProvideGeopriv ) )

        {

        // value must be "false" or "full"

        // 0 (false), 1 (full)

        TPtrC8 data = aXdmNode.LeafNodeContent();

        if ( data.CompareF( KXdmFalse )

             && data.CompareF( KXdmFull ) )

            {

            LeaveWithErrorL( KXcapErrorEnumerationRule );

            }

        found = ETrue;

        }

    // <service-id>

    else if ( Match( element, KXdmServiceId ) )

        {

        dataType = EDataTypeString;

        found = ETrue;

        }

    // NOTE the default namespace is IetfCommonPolicy

    if ( found )

        {

        SetPrefixL( aXdmNode, KXdmOmaPresRulesNsPrefix );

        }

    // urn:ietf:params:xml:ns:pres-rules

    // urn:ietf:params:xml:ns:common-policy

    // urn:oma:xml:xdm:common-policy

    else

        {

        // urn:ietf:params:xml:ns:common-policy

        found = iIetfCommonPolicy->ValidateNodeL( aXdmNode );

        if ( found )

            {

            // this means that this belongs to urn:ietf:params:xml:ns:common-policy,

            // there may be the prefix already

            // NOTE the default namespace is IetfCommonPolicy

                SetPrefixL( aXdmNode, KNullDesC8 );

                }

        else

            {

            // urn:ietf:params:xml:ns:pres-rules

            found = iIetfPresRules->ValidateNodeL( aXdmNode );

            if ( found )

                {

                SetPrefixL( aXdmNode, KXdmIetfPresRulesNsPrefix );

                }

            else

                {

                // urn:oma:xml:xdm:common-policy

                found = iOmaCommonPolicy->ValidateNodeL( aXdmNode );

                if ( found )

                    {

                    SetPrefixL( aXdmNode, KXdmOmaCommonPolicyNsPrefix );

                    }

                }

            }

        }

    if ( dataType != EDataTypeUndefined )

        {

        // pass to the base class for data validation

        ValidateDataL( dataType, aXdmNode );

        }

    return found;

    }

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

// CXcapOmaPresRulesUsage::ValidateAttributeL

// 

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

//

void CXcapOmaPresRulesUsage::ValidateAttributeL( const CXdmNodeAttribute& aXdmNodeAttr )

    {

    // This method is called by base class for each attribute

    // in document, here we have to define data types

    // for attributes, and pass them to the base class

    // for the actual data checking.

    // there aren't any attributes in

    // oma presence rules usage schema

    // urn:ietf:params:xml:ns:pres-rules

    // urn:ietf:params:xml:ns:common-policy

    iIetfPresRules->ValidateAttributeL( aXdmNodeAttr );

    }   

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

// CXcapOmaPresRulesUsage::AddNamespaceInformationL

// 

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

//

void CXcapOmaPresRulesUsage::AddNamespaceInformationL( CXdmDocument& aXdmDocument )

    {

    // NOTE the default namespace is IetfCommonPolicy

    aXdmDocument.AppendNamespaceL( KXdmIetfCommonPolicyNamespace, KNullDesC8 );

    aXdmDocument.AppendNamespaceL( KXdmOmaCommonPolicyNamespace, KXdmOmaCommonPolicyNsPrefix );

    aXdmDocument.AppendNamespaceL( KXdmOmaPresRulesNamespace, KXdmOmaPresRulesNsPrefix );

    aXdmDocument.AppendNamespaceL( KXdmIetfPresRulesNamespace, KXdmIetfPresRulesNsPrefix );

/*    aXdmDocument.AppendNamespaceL( KXdmOmaPresRulesNamespace, KNullDesC8 );

    aXdmDocument.AppendNamespaceL( KXdmIetfPresRulesNamespace, KXdmIetfPresRulesNsPrefix );

    aXdmDocument.AppendNamespaceL( KXdmIetfCommonPolicyNamespace, KXdmIetfCommonPolicyNsPrefix );*/

    }

// End of File