/*

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

*

*/

#include <XdmErrors.h>

#include <XdmDocumentNode.h>

#include <XdmNodeAttribute.h>

#include "XcapPocGroupUsage.h"

// Used specification

// OMA-TS-PoC_XDM-V1_0-20060609-A, 09 June 2006

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

// CXcapPocGroupUsage::CXcapPocGroupUsage

// 

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

//

CXcapPocGroupUsage::CXcapPocGroupUsage( const CXdmEngine& aXdmEngine ) :

CXcapAppUsage( aXdmEngine ),

iIetfCommonPolicies( NULL ),

iOmaCommonPolicies( NULL ),

iResourceLists( NULL )

    {

    }

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

// CXcapPocGroupUsage::NewL

// 

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

//

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

    {

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

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

    self->ConstructL();

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

    return self;

    }

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

// CXcapPocGroupUsage::~CXcapPocGroupUsage

// 

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

//

CXcapPocGroupUsage::~CXcapPocGroupUsage()

    {

    delete iIetfCommonPolicies;

    delete iOmaCommonPolicies;

    delete iResourceLists;

    }

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

// CXcapPocGroupUsage::ConstructL

// 

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

//

void CXcapPocGroupUsage::ConstructL()

    {

    iIetfCommonPolicies = CXcapAppUsage::NewL( iXdmEngine, EXdmIetfCommonPolicy );

    iOmaCommonPolicies = CXcapAppUsage::NewL( iXdmEngine, EXdmOmaCommonPolicy );

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

    }

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

// CXcapPocGroupUsage::AUID

// 

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

//

TPtrC8 CXcapPocGroupUsage::AUID() const

    {

    return TPtrC8( KXdmPocGroupUsageAUID );

    }

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

// CXcapPocGroupUsage::ContentType

// 

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

//

TPtrC8 CXcapPocGroupUsage::ContentType() const

    {

    return TPtrC8( KXdmPocGroupUsageContType );

    }

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

// CXcapPocGroupUsage::DefaultNamespace

// 

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

//

TPtrC8 CXcapPocGroupUsage::DefaultNamespace() const

    {

    return TPtrC8( KXdmPocGroupNamespace );

    }   

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

// CXcapPocGroupUsage::ValidateNodeL

// 

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

//

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

    // <group> 

    if ( Match( element, KXdmGroup ) )

        {

        // no other elements than <list-service>

        TInt count( aXdmNode.NodeCount() );

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

            {

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

                {

                LeaveWithErrorL( KXcapErrorSchemaViolation );   

                }

            }

        found = ETrue;

        }           

    // <list-service>

    else if ( Match( element, KXdmListService ) )

        {

        // required attribute uri

        if ( !aXdmNode.HasAttribute( KXdmUri ) )

            {

            LeaveWithErrorL( KXcapErrorMissingRequiredAttribute );

            }

        found = ETrue;

        }

    // <display-name>   

    else if ( Match( element, KXdmDisplayName ) )

        {

        CXdmDocumentNode* parent = aXdmNode.Parent();

        if ( parent && !parent->NodeName().CompareF( KXdmEntry ) )

            {

            found = iResourceLists->ValidateNodeL( aXdmNode );	

            if ( found )

            	{

            	SetPrefixL( aXdmNode, KXdmResourceListsNsPrefix );  

            	}

            }

        else

            {

        dataType = EDataTypeString;

        found = ETrue;

        }

        }

    // <invite-members>     

    else if ( Match( element, KXdmInviteMembers ) )

        {

        dataType = EDataTypeBoolean;

        found = ETrue;

        }

    // <max-participant-count>

    else if ( Match( element, KXdmMaxParticipantCount ) )

        {

        dataType = EDataTypeNonNegativeInteger;

        found = ETrue;

        }

    // <is-list-member>

    else if ( Match( element, KXdmIsListMember ) )

        {

        // dataType = EDataTypeBoolean; // OMA-TS-PoC_XDM-V1_0-20050317-C, 17 March 2005

        // changed 4-Nov-2005 PoC XDM

        dataType = EDataTypeEmpty;

        found = ETrue;

        }   

    // <allow-conference-state> 

    else if ( Match( element, KXdmAllowConfState ) )

        {

        dataType = EDataTypeBoolean;

        found = ETrue;

        }

    // <allow-invite-users-dynamically>

    else if ( Match( element, KXdmAllowInvUsersDyn ) )

        {

        dataType = EDataTypeBoolean;

        found = ETrue;

        }

    // <join-handling> 

    else if ( Match( element, KXdmJoinHandling ) )

        {

        // OMA-TS-PoC_XDM-V1_0-20050317-C, 17 March 2005

        // the value must be "allow" or "block"

        // 0 (block) and 1 (allow)

        /* TPtrC8 data = aXdmNode.LeafNodeContent();

        if ( data.CompareF( KXdmAllow )

             && data.CompareF( KXdmBlock ) )

            {

            LeaveWithErrorL( KXcapErrorEnumerationRule );

            }

        */

        // changed OMA-TS-PoC_XDM-V1_0-20060127-C, 27 January 2006

        dataType = EDataTypeBoolean;

        found = ETrue;

        }

    // <allow-initiate-conference>

    else if ( Match( element, KXdmAllowInitiateConf ) )

        {

        dataType = EDataTypeBoolean;

        found = ETrue;

        }

    // <allow-anonymity>

    else if ( Match( element, KXdmAllowAnonymity ) )

        {

        dataType = EDataTypeBoolean;

        found = ETrue;

        }

    // <is-key-participant>

    else if ( Match( element, KXdmIsKeyParticipant ) )

        {

        dataType = EDataTypeBoolean;

        found = ETrue;

        }

    // <external> 

    // type = rl:externalType from urn:ietf:params:xml:ns:resource-lists 

    // pass to the appropriate usage for validation

    // but use default namespace

    else if ( Match( element, KXdmExternal ) )

        {

        found = iResourceLists->ValidateNodeL( aXdmNode );

        }

    // <entry> 

    // type = rl:entryType from urn:ietf:params:xml:ns:resource-lists 

    // pass to the appropriate usage for validation

    // but use default namespace

    else if ( Match( element, KXdmEntry ) )    

        {

        found = iResourceLists->ValidateNodeL( aXdmNode );

        }

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

    if ( !found )

        {

        found = iIetfCommonPolicies->ValidateNodeL( aXdmNode );

        if ( found )

            {

            SetPrefixL( aXdmNode, KXdmIetfCommonPolicyNsPrefix );  

            }

        }

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

    if ( !found )

        {

        found = iOmaCommonPolicies->ValidateNodeL( aXdmNode );

        if ( found )

            {

            SetPrefixL( aXdmNode, KXdmOmaCommonPolicyNsPrefix );   

            }

        }

    // if the node is some of the basic types,

    // pass it to the base class for data validation

    if ( dataType != EDataTypeUndefined )

        {

        ValidateDataL( dataType, aXdmNode );

        }

    return found;   

    }

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

// CXcapPocGroupUsage::ValidateAttributeL

// 

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

//

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

    TPtrC attribute = aXdmNodeAttr.NodeName();

    // uri

    if ( Match( attribute, KXdmUri ) ) 

        {

        // pass to base class for data validation

        // check if this should be SIP uri

        ValidateDataL( EDataTypeAnyURI, aXdmNodeAttr ); 

        }

    else

        {

        // add parent element namespace checking when available,

        // now we don't know the attribute's namespace

        iIetfCommonPolicies->ValidateAttributeL( aXdmNodeAttr );

        iOmaCommonPolicies->ValidateAttributeL( aXdmNodeAttr ); 

        }

    }

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

// CXcapPocGroupUsage::AddNamespaceInformationL

// 

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

//

void CXcapPocGroupUsage::AddNamespaceInformationL( CXdmDocument& aXdmDocument )

    {

    aXdmDocument.AppendNamespaceL( KXdmPocGroupNamespace, KNullDesC8 );

    aXdmDocument.AppendNamespaceL( KXdmResourceListsNamespace, KXdmResourceListsNsPrefix );

    aXdmDocument.AppendNamespaceL( KXdmIetfCommonPolicyNamespace, KXdmIetfCommonPolicyNsPrefix );

    aXdmDocument.AppendNamespaceL( KXdmOmaCommonPolicyNamespace, KXdmOmaCommonPolicyNsPrefix );

    }

// End of File