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




#include "XcapIetfPresRulesUsage.h"
#include "XdmDocumentNode.h"
#include "XdmNodeAttribute.h"
#include "XdmErrors.h"

// Used specification
// draft-ietf-simple-presence-rules-03, 18 July 2005
// expires 19 January, 2006
// draft-ietf-simple-presence-rules-05, 06 March 2006
// expires 07 September, 2006

// ----------------------------------------------------
// CXcapIetfPresRulesUsage::CXcapIetfPresRulesUsage
// 
// ----------------------------------------------------
//
CXcapIetfPresRulesUsage::CXcapIetfPresRulesUsage( const CXdmEngine& aXdmEngine ) :
CXcapAppUsage( aXdmEngine ),
iIetfCommonPolicy( NULL )
    {
    }

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

// ----------------------------------------------------
// CXcapIetfPresRulesUsage::~CXcapIetfPresRulesUsage
// 
// ----------------------------------------------------
//
CXcapIetfPresRulesUsage::~CXcapIetfPresRulesUsage()
    {
    delete iIetfCommonPolicy;
    }
        
// ----------------------------------------------------
// CXcapIetfPresRulesUsage::ConstructL
// 
// ----------------------------------------------------
//
void CXcapIetfPresRulesUsage::ConstructL()
    {
    iIetfCommonPolicy = CXcapAppUsage::NewL( iXdmEngine, KXdmIetfCommonPolicyUsageUid );
    }

// ----------------------------------------------------
// CXcapIetfPresRulesUsage::AUID
// 
// ----------------------------------------------------
//
TPtrC8 CXcapIetfPresRulesUsage::AUID() const
    {
    return TPtrC8( KXdmIetfPresRulesUsageAUID );
    }
                
// ----------------------------------------------------
// CXcapIetfPresRulesUsage::ContentType
// 
// ----------------------------------------------------
//
TPtrC8 CXcapIetfPresRulesUsage::ContentType() const
    {
    return TPtrC8( KXdmIetfPresRulesUsageContType );
    }
    
// ----------------------------------------------------
// CXcapIetfPresRulesUsage::DefaultNamespace
// 
// ----------------------------------------------------
//
TPtrC8 CXcapIetfPresRulesUsage::DefaultNamespace() const
    {
    return TPtrC8( KXdmIetfPresRulesNamespace );
    }    

// ----------------------------------------------------
// CXcapIetfPresRulesUsage::ValidateL
// 
// ----------------------------------------------------
//
TBool CXcapIetfPresRulesUsage::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();
    
    // <service-uri-scheme>       
    if ( Match( element, KXdmServiceUriScheme ) )
        {
        dataType = EDataTypeToken;  
        found = ETrue;
        }
    // <class>
    else if ( Match( element, KXdmClass ) )
        {
        dataType = EDataTypeToken;
        found = ETrue;  
        }
    // <occurence-id>
    else if ( Match( element, KXdmOccurenceId ) ) 
        {
        dataType = EDataTypeToken;  
        found = ETrue;      
        }
    // <service-uri>
    else if ( Match( element, KXdmServiceUri ) )
        {
        dataType = EDataTypeAnyURI; 
        found = ETrue;      
        }
    // <all-services>
    else if ( Match( element, KXdmAllServices ) ) 
        {
        found = ETrue;
        }
    // <provide-services>
    else if ( Match( element, KXdmProvideServices ) )
        {
        // type = provideServicePermissions
        // here we should have either <all-services>
        // or sequence of other elements
        TBool allServices( EFalse );
        TBool sequence( EFalse );
        TBool serviceUri( EFalse );
        TBool serviceUriScheme( EFalse );
        TBool occurenceId( EFalse );
        TBool prclass( EFalse );
        TInt count( aXdmNode.NodeCount() );
        for ( TInt i(0); i < count; i++ )
            {
            TPtrC childName = aXdmNode.ChileNode(i)->NodeName();
            if ( Match( childName, KXdmAllServices ) ) 
                {
                allServices = ETrue;
                }
            else
                {
                sequence = ETrue;
                // in sequence should be either <service-uri>, 
                // <service-uri-scheme>, <occurence-id> or <class>
                if ( Match( childName, KXdmServiceUri ) ) 
                    {
                    serviceUri = ETrue;
                    }
                else if ( Match( childName, KXdmServiceUriScheme ) ) 
                    {
                    serviceUriScheme = ETrue;
                    }
                else if ( Match( childName, KXdmOccurenceId ) ) 
                    {
                    occurenceId = ETrue;
                    }
                else if ( Match( childName, KXdmClass ) ) 
                    {
                    prclass = ETrue;
                    }
                }
            }
        if ( allServices && sequence )
            {
            LeaveWithErrorL( KXcapErrorSchemaViolation );
            }
        if ( sequence ) 
            {
            if ( serviceUri && ( serviceUriScheme || occurenceId || prclass ) )
                {
                LeaveWithErrorL( KXcapErrorSchemaViolation );
                }
            if ( serviceUriScheme && ( occurenceId || prclass ) )
                {
                LeaveWithErrorL( KXcapErrorSchemaViolation );
                }
            if ( occurenceId && prclass )
                {
                LeaveWithErrorL( KXcapErrorSchemaViolation );
                }       
            }
        found = ETrue;
        }
    // used in presence-rules-03
    // <device-id>
    else if ( Match( element, KXdmDeviceId ) )
        {
        dataType = EDataTypeAnyURI; 
        found = ETrue;          
        }
    // used in presence-rules-05
    // <deviceID>
    else if ( Match( element, KXdmDeviceID ) )
        {
        dataType = EDataTypeAnyURI; 
        found = ETrue;          
        }
    // <all-devices>
    else if ( Match( element, KXdmAllDevices ) )
        {
        found = ETrue;
        }
    // <provide-devices>
    else if ( Match( element, KXdmProvideDevices ) )
        {
        // type = provideDevicePermissions
        // here we should have either <all-devices>
        // or sequence of other elements
        TBool allDevices( EFalse );
        TBool sequence( EFalse );
        TBool deviceId( EFalse );
        TBool occurenceId( EFalse );
        TBool prclass( EFalse );
        TInt count( aXdmNode.NodeCount() );
        for ( TInt i(0); i < count; i++ )
            {
            TPtrC childName = aXdmNode.ChileNode(i)->NodeName();
            if ( Match( childName, KXdmAllDevices ) ) 
                {
                allDevices = ETrue;
                }
            else
                {
                sequence = ETrue;
                // in sequence should be either pres-rules-03 <device-id> pres-rules-05 <deviceID>, 
                // <occurence-id> or <class>
                if ( Match( childName, KXdmDeviceId ) 
                    || Match( childName, KXdmDeviceID ) ) 
                    {
                    deviceId = ETrue;
                    }
                else if ( Match( childName, KXdmOccurenceId ) ) 
                    {
                    occurenceId = ETrue;
                    }
                else if ( Match( childName, KXdmClass ) ) 
                    {
                    prclass = ETrue;
                    }
                }
            }
            if ( allDevices && sequence )
                {
                LeaveWithErrorL( KXcapErrorSchemaViolation );
                }
            if ( sequence ) 
                {
                if ( deviceId && ( occurenceId || prclass ) )
                    {
                    LeaveWithErrorL( KXcapErrorSchemaViolation );
                    }
                if ( occurenceId && prclass )
                    {
                    LeaveWithErrorL( KXcapErrorSchemaViolation );
                    }
                }
        found = ETrue;
        }
    // <all-persons>
    else if ( Match( element, KXdmAllPersons ) )
        {
        found = ETrue;
        }
    //  <provide-persons>
    else if ( !element.CompareF( KXdmProvidePersons ) )
        {
        // type = providePersonPermissions
        // here we should have either <all-devices>
        // or sequence of other elements
        TBool allPersons( EFalse );
        TBool sequence( EFalse );
        TBool occurenceId( EFalse );
        TBool prclass( EFalse );
        TInt count( aXdmNode.NodeCount() );
        for ( TInt i(0); i < count; i++ )
            {
            TPtrC childName = aXdmNode.ChileNode(i)->NodeName();
            if ( Match( childName, KXdmAllPersons ) ) 
                {
                allPersons = ETrue;
                }
            else
                {
                sequence = ETrue;
                // in sequence should be either 
                // <occurence-id> or <class>
                if ( Match( childName, KXdmOccurenceId ) ) 
                    {
                    occurenceId = ETrue;
                    }
                else if ( Match( childName, KXdmClass ) ) 
                    {
                    prclass = ETrue;
                    }
                }
            }
            if ( allPersons && sequence )
                {
                LeaveWithErrorL( KXcapErrorSchemaViolation );
                }
            if ( sequence ) 
                {
                if ( occurenceId && prclass )
                    {
                    LeaveWithErrorL( KXcapErrorSchemaViolation );
                    }
                }
        found = ETrue;              
        }
    // <provide-activities>
    else if ( Match( element, KXdmProvideActivities ) )
        {
        dataType = EDataTypeBoolean;
        found = ETrue;              
        }
    // <provide-class>
    else if ( Match( element, KXdmProvideClass ) )
        {
        dataType = EDataTypeBoolean;
        found = ETrue;          
        }
    // <provide-device-id>
    else if ( Match( element, KXdmProvideDeviceId ) )
        {
        dataType = EDataTypeBoolean;            
        found = ETrue;
        }
    // <provide-mood>
    else if ( Match( element, KXdmProvideMood ) )
        {
        dataType = EDataTypeBoolean;            
        found = ETrue;
        }
    // <provide-place-is>
    else if ( Match( element, KXdmProvidePlaceIs ) )
        {
        dataType = EDataTypeBoolean;            
        found = ETrue;
        }
    // <provide-place-type>
    else if ( Match( element, KXdmProvidePlaceType ) )
        {
        dataType = EDataTypeBoolean;            
        found = ETrue;
        }
    // <provide-privacy>
    else if ( Match( element, KXdmProvidePrivacy ) )
        {
        dataType = EDataTypeBoolean;            
        found = ETrue;
        }
    // <provide-relationship>
    else if ( Match( element, KXdmProvideRelationship ) )
        {
        dataType = EDataTypeBoolean;            
        found = ETrue;
        }
    // <provide-status-icon>
    else if ( Match( element, KXdmProvideStatusIcon ) )
        {
        dataType = EDataTypeBoolean;            
        found = ETrue;
        }
    // <provide-sphere>
    else if ( Match( element, KXdmProvideSphere ) )
        {
        dataType = EDataTypeBoolean;            
        found = ETrue;
        }
    // <provide-time-offset>
    else if ( Match( element, KXdmProvideTimeOffset ) )
        {
        dataType = EDataTypeBoolean;            
        found = ETrue;
        }
    // <provide-user-input>
    else if ( Match( element, KXdmProvideUserInput ) )
        {
        // value is restricted, allowed values
        // are "false", "bare", "thresholds" and "full" 
        TPtrC8 data = aXdmNode.LeafNodeContent();
        if ( data.CompareF( KXdmFalse )
             && data.CompareF( KXdmBare )
             && data.CompareF( KXdmThresholds )
             && data.CompareF( KXdmFull ) )
            {
            LeaveWithErrorL( KXcapErrorEnumerationRule );
            }
        found = ETrue;
        }
    // <provide-note>
    else if ( Match( element, KXdmProvideNote ) )
        {
        dataType = EDataTypeBoolean;            
        found = ETrue;
        }
    // <provide-unknown-attribute>
    else if ( Match( element, KXdmProvideUnknownAttribute ) )
        {
        // required attribute name
        if ( !aXdmNode.HasAttribute( KXdmName ) )
            {
            LeaveWithErrorL( KXcapErrorMissingRequiredAttribute );
            }   
        found = ETrue;
        }
    // <provide-all-attributes>
    else if ( Match( element, KXdmProvideAllAttributes ) )
        {
        found = ETrue;
        }
    // <sub-handling>
    else if ( Match( element, KXdmSubHandling ) )
        {
        found = ETrue;
        // value is restricted, allowed values
        // are "block", "confirm", "polite-block" and "allow" 
        TPtrC8 data = aXdmNode.LeafNodeContent();
        if ( data.CompareF( KXdmBlock )
             && data.CompareF( KXdmConfirm )
             && data.CompareF( KXdmPoliteBlock )
             && data.CompareF( KXdmAllow ) )
            {
            LeaveWithErrorL( KXcapErrorEnumerationRule );
            }
        }
    // urn:ietf:params:xml:ns:common-policy
    if ( !found )
        {
        found = iIetfCommonPolicy->ValidateNodeL( aXdmNode );
        if ( found )
            {
            SetPrefixL( aXdmNode, KXdmIetfCommonPolicyNsPrefix );  
            }
        }
        
    if ( dataType != EDataTypeUndefined )
        {
        // pass to the base class for data validation
        ValidateDataL( dataType, aXdmNode );
        }
    return found;
    }

// ----------------------------------------------------
// CXcapIetfPresRulesUsage::ValidateAttributeL
// 
// ----------------------------------------------------
//
void CXcapIetfPresRulesUsage::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.
    
    // name 
    if ( Match( aXdmNodeAttr.NodeName(), KXdmName ) )
        {       
        // pass to base class for data validation
        ValidateDataL( EDataTypeString, aXdmNodeAttr );    
        }
    // the rest are from urn:ietf:params:xml:ns:common-policy
    else
        {
        iIetfCommonPolicy->ValidateAttributeL( aXdmNodeAttr );  
        }
     }   
                         
// ----------------------------------------------------
// CXcapIetfPresRulesUsage::AddNamespaceInformationL
// 
// ----------------------------------------------------
//
void CXcapIetfPresRulesUsage::AddNamespaceInformationL( CXdmDocument& aXdmDocument )
    {
    aXdmDocument.AppendNamespaceL( KXdmIetfPresRulesNamespace, KNullDesC8 );
    aXdmDocument.AppendNamespaceL( KXdmIetfPresRulesNamespace, KXdmIetfPresRulesNsPrefix ); // ESTI-7AY95P 
    aXdmDocument.AppendNamespaceL( KXdmIetfCommonPolicyNamespace, KXdmIetfCommonPolicyNsPrefix ); // ESTI-7AY95P 
    }


// End of File