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




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

// Used specifications
// draft-ietf-geopriv-common-policy-08, 05 March 2006, expires 06 September 2006

// ----------------------------------------------------
// CXcapIetfCommonPolicyUsage::CXcapIetfCommonPolicyUsage
// 
// ----------------------------------------------------
//
CXcapIetfCommonPolicyUsage::CXcapIetfCommonPolicyUsage( const CXdmEngine& aXdmEngine ) 
:CXcapAppUsage( aXdmEngine )
    {
    }

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

// ----------------------------------------------------
// CXcapIetfCommonPolicyUsage::~CXcapIetfCommonPolicyUsage
// 
// ----------------------------------------------------
//
CXcapIetfCommonPolicyUsage::~CXcapIetfCommonPolicyUsage()
    {
    }
        
// ----------------------------------------------------
// CXcapIetfCommonPolicyUsage::ConstructL
// 
// ----------------------------------------------------
//
void CXcapIetfCommonPolicyUsage::ConstructL()
    {
    }

// ----------------------------------------------------
// CXcapIetfCommonPolicyUsage::AUID
// 
// ----------------------------------------------------
//
TPtrC8 CXcapIetfCommonPolicyUsage::AUID() const
    {
    return TPtrC8( KXdmIetfCommonPolicyUsageAUID );
    }
                
// ----------------------------------------------------
// CXcapIetfCommonPolicyUsage::ContentType
// 
// ----------------------------------------------------
//
TPtrC8 CXcapIetfCommonPolicyUsage::ContentType() const
    {
    return TPtrC8( KXdmIetfCommonPolicyUsageContType );
    }

// ----------------------------------------------------
// CXcapIetfCommonPolicyUsage::DefaultNamespace
// 
// ----------------------------------------------------
//
TPtrC8 CXcapIetfCommonPolicyUsage::DefaultNamespace() const
    {
    return TPtrC8( KXdmIetfCommonPolicyNamespace );
    }   
    
// ----------------------------------------------------
// CXcapIetfCommonPolicyUsage::ValidateNodeL
// 
// ----------------------------------------------------
//
TBool CXcapIetfCommonPolicyUsage::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();
            
    // <ruleset> 
    if ( Match( element, KXdmRuleset ) )
        {
        TInt count( aXdmNode.NodeCount() );
        for ( TInt i(0); i < count; i++ )
            {
            // ruleset should not contain any other type elements
            // than <rule>
            if ( !Match( aXdmNode.ChileNode(i)->NodeName(), KXdmRule ) ) 
                {
                LeaveWithErrorL( KXcapErrorSchemaViolation );
                }
            }
        found = ETrue;
        }
    // <rule> 
    else if ( Match( element, KXdmRule ) )
        {
        // required attribute id
        if ( !aXdmNode.HasAttribute( KXdmId ) )
            {
            LeaveWithErrorL( KXcapErrorMissingRequiredAttribute );
            }
        found = ETrue;
        }
    // <conditions> 
    else if ( Match( element, KXdmConditions ) )
        {
        found = ETrue;
        }
    // <actions> 
    else if ( Match( element, KXdmActions ) )
        {
        found = ETrue;
        }
    // <transformations> 
    else if ( Match( element, KXdmTransformations ) )
        {
        found = ETrue;
        }
    // <validity> 
    else if ( Match( element, KXdmValidity ) )
        {
            // <validity> should contain <from> and <until>
            TBool from( EFalse );
            TBool until( EFalse );
            TInt count( aXdmNode.NodeCount() );
            for ( TInt i(0); i < count; i++ )
                {
                TPtrC childName = aXdmNode.ChileNode(i)->NodeName();
                if ( Match( childName, KXdmFrom ) ) 
                    {
                    from = ETrue;
                    }
                else if ( Match( childName, KXdmUntil ) ) 
                    {
                    until = ETrue;
                    }
                }
            if ( !from || !until ) 
                {
                LeaveWithErrorL( KXcapErrorMissingRequiredElement );    
                }    
        found = ETrue;
        }
    // <from> 
    else if ( Match( element, KXdmFrom ) )
        {
        dataType = EDataTypeDateTime;
        found = ETrue;
        }
    // <to> 
    else if ( Match( element, KXdmTo ) )
        {
        dataType = EDataTypeDateTime;
        found = ETrue;
        }
    // <identity> 
    else if ( Match( element, KXdmIdentity ) )
        {
        // <identity> should contain either <one> or <many>
        // elements, not both
        TBool one( EFalse );
        TBool many( EFalse );
        TInt count( aXdmNode.NodeCount() );
        for ( TInt i(0); i < count; i++ )
            {
            TPtrC childName = aXdmNode.ChileNode(i)->NodeName();
            if ( Match( childName, KXdmOne ) ) 
                {
                one = ETrue;
        }
            else if ( Match( childName, KXdmMany ) ) 
                {
                many = ETrue;
                }    
            }
        if ( one && many )
            {
            LeaveWithErrorL( KXcapErrorSchemaViolation );
            }
        found = ETrue;
        }
    // <id> 
    else if ( Match( element, KXdmId ) )
        {
        // required attribute entity
        if ( !aXdmNode.HasAttribute( KXdmEntity ) )
            {
            LeaveWithErrorL( KXcapErrorMissingRequiredAttribute );
            }
        found = ETrue;
        }
    // <any-identity> 
    else if ( Match( element, KXdmAnyIdentity ) )
        {
        found = ETrue;
        }
    // <except> 
    else if ( Match( element, KXdmExcept ) )
        {
        found = ETrue;
        }   
    // <sphere> 
    else if ( Match( element, KXdmSphere ) )
        {
        // required attribute value
        if ( !aXdmNode.HasAttribute( KXdmValue ) )
            {
            LeaveWithErrorL( KXcapErrorMissingRequiredAttribute );
            }
        found = ETrue;
        }
    // <one> 
    else if ( Match( element, KXdmOne ) )
        {
        // required attribute id
        if ( !aXdmNode.HasAttribute( KXdmId ) )
            {
            LeaveWithErrorL( KXcapErrorMissingRequiredAttribute );
            }
        found = ETrue;
        }
    // <many> 
    else if ( Match( element, KXdmMany) )
        {
        found = ETrue;
        }
    // <until> 
    else if ( Match( element, KXdmUntil ) )
        {
        dataType = EDataTypeDateTime;
        found = ETrue;
        }        

    // 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;   
    }
                            
// ----------------------------------------------------
// CXcapIetfCommonPolicyUsage::ValidateAttributeL
// 
// ----------------------------------------------------
//
void CXcapIetfCommonPolicyUsage::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.
        
    TDataType dataType ( EDataTypeUndefined );
    TPtrC attribute = aXdmNodeAttr.NodeName();

    // id 
    if ( Match( attribute, KXdmId ) )
        {
        dataType = EDataTypeString;
        }
        // domain 
    else if ( Match( attribute, KXdmDomain ) )
        {
        dataType = EDataTypeString;
        }
    // value 
    else if ( Match( attribute, KXdmValue ) )
        {
        dataType = EDataTypeString;
        }

    // pass to base class for data validation
    ValidateDataL( dataType, aXdmNodeAttr );
    }
                            
// ----------------------------------------------------
// CXcapIetfCommonPolicyUsage::AddNamespaceInformationL
// 
// ----------------------------------------------------
//
void CXcapIetfCommonPolicyUsage::AddNamespaceInformationL( CXdmDocument& aXdmDocument )
	{
    aXdmDocument.AppendNamespaceL( KXdmIetfCommonPolicyNamespace, KNullDesC8 );
	}

// End of File