/*
* 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:  CXcapPocUserAccessUsage
*
*/




#include <XdmErrors.h>
#include <XdmDocumentNode.h>
#include <XdmNodeAttribute.h>
#include "XcapPocUserAccessUsage.h"

// Used specification
// OMA-TS-PoC_XDM-V1_0-20050317-C, 17 March 2005
// OMA-TS-PoC_XDM-V1_0-20060127-C, 27 January 2006

// ----------------------------------------------------
// CXcapPocUserAccessUsage::CXcapPocUserAccessUsage
// 
// ----------------------------------------------------
//
CXcapPocUserAccessUsage::CXcapPocUserAccessUsage( const CXdmEngine& aXdmEngine ) :
CXcapAppUsage( aXdmEngine ),
iIetfCommonPolicies( NULL ),
iOmaCommonPolicies( NULL )
    {
    }

// ----------------------------------------------------
// CXcapPocUserAccessUsage::NewL
// 
// ----------------------------------------------------
//
CXcapPocUserAccessUsage* CXcapPocUserAccessUsage::NewL( const TXcapAppUsageParams& aParameters )
    {
    CXcapPocUserAccessUsage* self = new ( ELeave ) CXcapPocUserAccessUsage( aParameters.iXdmEngine );
    CleanupStack::PushL( self );	// << self
    self->ConstructL();
    CleanupStack::Pop( self );      // >> self
    return self;
    }

// ----------------------------------------------------
// CXcapPocUserAccessUsage::~CXcapPocUserAccessUsage
// 
// ----------------------------------------------------
//
CXcapPocUserAccessUsage::~CXcapPocUserAccessUsage()
    {
    delete iIetfCommonPolicies;
    delete iOmaCommonPolicies;
    }
        
// ----------------------------------------------------
// CXcapPocUserAccessUsage::ConstructL
// 
// ----------------------------------------------------
//
void CXcapPocUserAccessUsage::ConstructL()
    {
    iIetfCommonPolicies = CXcapAppUsage::NewL( iXdmEngine, EXdmIetfCommonPolicy );
    iOmaCommonPolicies = CXcapAppUsage::NewL( iXdmEngine, EXdmOmaCommonPolicy );
    }

// ----------------------------------------------------
// CXcapPocUserAccessUsage::AUID
// 
// ----------------------------------------------------
//
TPtrC8 CXcapPocUserAccessUsage::AUID() const
    {
    return TPtrC8( KXdmPocUserAccessUsageAUID );
    }

// ----------------------------------------------------
// CXcapPocUserAccessUsage::ContentType
// 
// ----------------------------------------------------
//
TPtrC8 CXcapPocUserAccessUsage::ContentType() const
    {
    return TPtrC8( KXdmPocUserAccessUsageContType );
    }

// ----------------------------------------------------
// CXcapPocUserAccessUsage::DefaultNamespace
// 
// ----------------------------------------------------
//
TPtrC8 CXcapPocUserAccessUsage::DefaultNamespace() const
    {
//    return TPtrC8( KXdmPocUserAccessNamespace );
    // NOTE the default namespace is IetfCommonPolicy
    return TPtrC8( KXdmIetfCommonPolicyNamespace );
    }   
    
// ----------------------------------------------------
// CXcapPocUserAccessUsage::ValidateNodeL
// 
// ----------------------------------------------------
//
TBool CXcapPocUserAccessUsage::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 );
    TPtrC element = aXdmNode.NodeName();
    
    // there is restriction for the value 
    // of <allow-invite>
    // check that value is either "reject", "accept" or "pass"
    // 0 (reject), 1 (pass), 2 (accept)
    if ( Match( element, KXdmAllowInvite ) )
        {
        TPtrC8 data = aXdmNode.LeafNodeContent();
        if ( data.CompareF( KXdmReject )
             && data.CompareF( KXdmAccept )
             && data.CompareF( KXdmPass ) )
            {
            LeaveWithErrorL( KXcapErrorEnumerationRule );
            }
        found = ETrue;
        // NOTE the default namespace is IetfCommonPolicy
        SetPrefixL( aXdmNode, KXdmPocUserAccessNsPrefix ); 
        }
    // urn:ietf:params:xml:ns:common-policy
    if ( !found )
        {
        found = iIetfCommonPolicies->ValidateNodeL( aXdmNode );
        // NOTE the default namespace is IetfCommonPolicy
        /*if ( found )
            {
            SetPrefixL( aXdmNode, KXdmIetfCommonPolicyNsPrefix );  
            }*/
        }
    // urn:oma:params:xml:ns:common-policy
    if ( !found )
        {
        found = iOmaCommonPolicies->ValidateNodeL( aXdmNode );
                if ( found )
            {
            SetPrefixL( aXdmNode, KXdmOmaCommonPolicyNsPrefix );   
            }
        }
    return found;
    }
        
// ----------------------------------------------------
// CXcapPocUserAccessUsage::ValidateAttributeL
// 
// ----------------------------------------------------
//
void CXcapPocUserAccessUsage::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, all attributes are
    // either from urn:ietf:params:xml:ns:common-policy
    // or from urn:oma:params:xml:ns:common-policy
    
    // add parent element namespace checking when available,
    // now we don't know the attribute's namespace
    iIetfCommonPolicies->ValidateAttributeL( aXdmNodeAttr );
    iOmaCommonPolicies->ValidateAttributeL( aXdmNodeAttr ); 
    }
        

 // ----------------------------------------------------
// CXcapPocUserAccessUsage::AddNamespaceInformationL
// 
// ----------------------------------------------------
//
void CXcapPocUserAccessUsage::AddNamespaceInformationL( CXdmDocument& aXdmDocument )
    {
    aXdmDocument.AppendNamespaceL( KXdmIetfCommonPolicyNamespace, KNullDesC8 );
    aXdmDocument.AppendNamespaceL( KXdmPocUserAccessNamespace, KXdmPocUserAccessNsPrefix );
    aXdmDocument.AppendNamespaceL( KXdmOmaCommonPolicyNamespace, KXdmOmaCommonPolicyNsPrefix );
/*    aXdmDocument.AppendNamespaceL( KXdmPocUserAccessNamespace, KNullDesC8 );
    aXdmDocument.AppendNamespaceL( KXdmIetfCommonPolicyNamespace, KXdmIetfCommonPolicyNsPrefix );
    aXdmDocument.AppendNamespaceL( KXdmOmaCommonPolicyNamespace, KXdmOmaCommonPolicyNsPrefix );*/
    }                           
                           
                           
// End of File