/*

* 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:  CXcapRlsServicesUsage

*

*/

#include <XdmErrors.h>

#include <XdmDocumentNode.h>

#include <XdmNodeAttribute.h>

#include "XcapRlsServicesUsage.h"

// Used specification

// OMA-RLS_XDM_Specification-V1_0-20060214-C, 14 February 2006

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

// CXcapRlsServicesUsage::CXcapRlsServicesUsage

// 

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

//

CXcapRlsServicesUsage::CXcapRlsServicesUsage( const CXdmEngine& aXdmEngine ) :

CXcapAppUsage( aXdmEngine ),

iResourceLists( NULL )

    {

    }

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

// CXcapRlsServicesUsage::NewL

// 

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

//

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

    {

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

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

    self->ConstructL();

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

    return self;

    }

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

// CXcapRlsServicesUsage::~CXcapRlsServicesUsage

// 

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

//

CXcapRlsServicesUsage::~CXcapRlsServicesUsage()

    {

    delete iResourceLists;

    }

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

// CXcapRlsServicesUsage::ConstructL

// 

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

//

void CXcapRlsServicesUsage::ConstructL()

    {

    iResourceLists = CXcapAppUsage::NewL( iXdmEngine, KXdmResourceListsUsageUid );

    }

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

// CXcapRlsServicesUsage::AUID

// 

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

//

TPtrC8 CXcapRlsServicesUsage::AUID() const

    {

    return TPtrC8( KXdmRlsServicesUsageAUID );

    }

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

// CXcapRlsServicesUsage::ContentType

// 

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

//

TPtrC8 CXcapRlsServicesUsage::ContentType() const

    {

    return TPtrC8( KXdmRlsServicesUsageContType );

    }

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

// CXcapRlsServicesUsage::DefaultNamespace

// 

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

//

TPtrC8 CXcapRlsServicesUsage::DefaultNamespace() const

    {

    return TPtrC8( KXdmRlsServicesNamespace );

    }   

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

// CXcapRlsServicesUsage::ValidateNodeL

// 

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

//

TBool CXcapRlsServicesUsage::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();

    // <rls-services>

    if ( Match( element, KXdmRlsServices ) )   

        {

        found = ETrue;

        }

     // <service>

    else if ( Match( element, KXdmService ) )    

        {

        // required attribute uri

        if ( !aXdmNode.HasAttribute( KXdmUri ) )

            {

            LeaveWithErrorL( KXcapErrorMissingRequiredAttribute );

            }

        // there should be either <resource-list> or

        // <list> element and mandatory <packages> element

        TBool resourcelist( EFalse );

        TBool list( EFalse );

        TBool packages( EFalse );

        // go through all childs

        TInt count( aXdmNode.NodeCount() );

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

            {

            TPtrC childName = aXdmNode.ChileNode(i)->NodeName();

            if ( Match( childName, KXdmResourceList ) )  

                {

                resourcelist = ETrue;

                }

            else if ( Match( childName, KXdmList ) ) 

                {

                list = ETrue;

                }

            else if ( Match( childName, KXdmPackages ) ) 

                {

                packages = ETrue;

                }

            }

        // <resource-list> or <list>, not both

        if ( resourcelist && list )

            {

            LeaveWithErrorL( KXcapErrorSchemaViolation );   

            }

        // each <service> must have at least one <packages> element

        if ( !packages )

            {

            LeaveWithErrorL( KXcapErrorMissingRequiredElement );    

            }

        found = ETrue;

        }

    // <resource-list>

    else if ( Match( element, KXdmResourceList ) )   

        {

        dataType = EDataTypeAnyURI;

        found = ETrue;

        }

    // <packages>

    else if ( Match( element, KXdmPackages ) )   

        {

        // each <packages> shall specify at least presence event package,

        // go through all childs

        TBool presence ( EFalse );

        TInt count( aXdmNode.NodeCount() );

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

            {   

            if ( Match( aXdmNode.ChileNode(i)->NodeName(), KXdmPackage ) ) 

                {

                TPtrC8 data = aXdmNode.ChileNode(i)->LeafNodeContent();

                if ( !data.CompareF( KXdmPresence ) )

                    {

                    presence = ETrue;

                    }

                }

            }

        // check that the <package>presence<package> exists

        if ( !presence )

            {

            LeaveWithErrorL( KXcapErrorMissingRequiredElementValue );   

            }

        found = ETrue;

        }

    // <package>

    else if ( Match( element, KXdmPackage ) )   

        {

        dataType = EDataTypeString;

        found = ETrue;

        }

    // <list> type=rl:listType from urn:ietf:params:xml:ns:resource-lists

    // however belongs to the default namespace

    // ( btw, there is mistake in specification example )

    else if ( Match( element, KXdmList ) ) 

        {

        found = iResourceLists->ValidateNodeL( aXdmNode );

        }

    // <entry>,<display-name> from urn:ietf:params:xml:ns:resource-lists

    if ( !found ) 

        {

        found = iResourceLists->ValidateNodeL( aXdmNode );

        if ( found )

            {

            SetPrefixL( aXdmNode, KXdmResourceListsNsPrefix );   

            }

        }

    if ( dataType != EDataTypeUndefined )

        {

        // pass to the base class for data validation

        ValidateDataL( dataType, aXdmNode );

        }

    return found;

    }

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

// CXcapRlsServicesUsage::ValidateAttributeL

// 

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

//

void CXcapRlsServicesUsage::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.

    // uri 

    if ( Match( aXdmNodeAttr.NodeName(), KXdmUri ) )

        {

        ValidateDataL( EDataTypeAnyURI, aXdmNodeAttr );

        }

    // the rest are rom urn:ietf:params:xml:ns:resource-lists

    else

        {

        iResourceLists->ValidateAttributeL( aXdmNodeAttr ); 

        }

    }   

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

// CXcapRlsServicesUsage::AddNamespaceInformationL

// 

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

//

void CXcapRlsServicesUsage::AddNamespaceInformationL( CXdmDocument& aXdmDocument )

    {

    aXdmDocument.AppendNamespaceL( KXdmRlsServicesNamespace, KNullDesC8 );

    aXdmDocument.AppendNamespaceL( KXdmResourceListsNamespace, KXdmResourceListsNsPrefix );

    }

// End of File