/*
* Copyright (c) 2002-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:       
*
*/








// INCLUDE FILES
#include "seninternalwspolicy.h"
#include "SenFacet.h"
#include <SenXmlElement.h>
#include <SenXmlUtils.h>
#include "senwsdescription.h"
#include "SenDateUtils.h"
#include "senservicepolicy.h"
#include "wspolicyutils.h"


#ifdef SYMBIAN_SECURE_ECOM
    // for S60 FP3 (2.8) platform or newer (3.0 and above)
    #include <xml/attribute.h> // needed for RAttributeArray
//#else  // for S60 FP2 platform (2.6) or older
    //#include "Attribute.h"
#endif

#include <xml/dom/xmlengnodelist.h> 
using namespace Xml;
using namespace SenWSInternalPolicy;
namespace
    {
    const TInt KFlatBufSize                       = 128;
    }
CSenInternalWsPolicy* CSenInternalWsPolicy::NewL()
    {
    CSenInternalWsPolicy* pNew = NewLC();
    CleanupStack::Pop(); // pNew;
    return pNew;
    }

CSenInternalWsPolicy* CSenInternalWsPolicy::NewLC()
    {
    CSenInternalWsPolicy* pNew = new (ELeave) CSenInternalWsPolicy;
    CleanupStack::PushL(pNew);
    pNew->ConstructL(KSenWSPolicyMetadata);
    return pNew;
    }

CSenInternalWsPolicy* CSenInternalWsPolicy::NewL(
                                           	const TDesC8& aNsUri,
                                            const TDesC8& aLocalName,
                                            const TDesC8& aQName,
                                            const RAttributeArray& aAttributes)
    {
    CSenInternalWsPolicy* pNew = NewLC(aNsUri, aLocalName, aQName, aAttributes);
    CleanupStack::Pop(); // pNew;
    return pNew;
    }

CSenInternalWsPolicy* CSenInternalWsPolicy::NewLC(
                                            const TDesC8& aNsUri,
                                            const TDesC8& aLocalName,
                                            const TDesC8& aQName,
                                            const RAttributeArray& aAttributes)
    {
    CSenInternalWsPolicy* pNew = new (ELeave) CSenInternalWsPolicy;
    CleanupStack::PushL(pNew);
    pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes);
    return pNew;
    }

CSenInternalWsPolicy* CSenInternalWsPolicy::NewL(
                                            const TDesC8& aNsUri,
                                            const TDesC8& aLocalName,
                                            const TDesC8& aQName,
                                            const RAttributeArray& aAttributes,
                                             CSenElement& aParent)
    {
    CSenInternalWsPolicy* pNew = NewLC(aNsUri, aLocalName,
                                         aQName, aAttributes, aParent);
    CleanupStack::Pop(); // pNew;
    return pNew;
    }

CSenInternalWsPolicy* CSenInternalWsPolicy::NewLC(
                                            const TDesC8& aNsUri,
                                            const TDesC8& aLocalName,
                                            const TDesC8& aQName,
                                            const RAttributeArray& aAttributes,
                                            CSenElement& aParent)
    {
    CSenInternalWsPolicy* pNew = new (ELeave) CSenInternalWsPolicy;
    CleanupStack::PushL(pNew);
    pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent);
    return pNew;
    }
void CSenInternalWsPolicy::ConstructL(const TDesC8&  aNsUri,
                                          const TDesC8&  aLocalName,
                                          const TDesC8&  aQName,
                                          const RAttributeArray& aAttributes,
                                           CSenElement& aParent)
    {
    BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent);
    }
void CSenInternalWsPolicy::ConstructL(const TDesC8&  aNsUri,
                                          const TDesC8&  aLocalName,
                                          const TDesC8&  aQName,
                                          const RAttributeArray& aAttributes)
    {
    BaseConstructL(aNsUri, aLocalName, aQName, aAttributes);
    }
  
void CSenInternalWsPolicy::ConstructL(const TDesC8& aLocalName)
    {
    CSenBaseFragment::BaseConstructL(aLocalName);
    }

CSenInternalWsPolicy::CSenInternalWsPolicy()
    {
    }

CSenInternalWsPolicy::~CSenInternalWsPolicy()
    {
    delete ipIdentifier;
    }

TBool CSenInternalWsPolicy::IsApplicableL(CSenWSDescription& aPattern)
    {
    TPtrC8 value;
    CSenElement& patternElement = ((CSenWSDescription&)aPattern).AsElement();
    CSenWSPolicyIdentifier& identifier = IdentifierL();

    TPtrC8 contract = aPattern.Contract();
    TPtrC8 endpoint = aPattern.Endpoint();
    CSenElement* providerId = aPattern.AsElement().Element(KProviderIdLocalName);
    if(providerId && providerId->HasContent())     
        {
        TPtrC8 provider = providerId->Content();    
        TPtrC8 valProviderId = identifier.ProviderIdL();
        TPtrC8 valEndpoint = identifier.EndpointL();
        TPtrC8 valContract = identifier.ContractL();
    
        if(contract == valContract && 
            endpoint == valEndpoint && 
            provider == valProviderId)
            {
            return ETrue;     
            }
        }
    return EFalse;    
    }
    
TBool CSenInternalWsPolicy::IsApplicableL(const TDesC8& aPolicyEndpoint)
    {
    CSenWSPolicyIdentifier& identifier = IdentifierL();

        TPtrC8 valEndpoint = identifier.MetadataEndpointL();
        if(valEndpoint == aPolicyEndpoint)
        {
            return ETrue;     
        }
    return EFalse;    
    }

TBool CSenInternalWsPolicy::IsApplicableL(CSenInternalWsPolicy* aInternalPolicy)
{
    CSenWSPolicyIdentifier& identifier = IdentifierL();
    CSenWSPolicyIdentifier& id = aInternalPolicy->IdentifierL();

        TPtrC8 valmetaEndpoint = identifier.MetadataEndpointL();
        TPtrC8 metaendpoint = id.MetadataEndpointL();
        TPtrC8 valEndpoint = identifier.EndpointL();
        TPtrC8 endpoint = id.EndpointL();
        TPtrC8 valcontract = identifier.ContractL();
        TPtrC8 contract = id.ContractL();

        if(valmetaEndpoint == metaendpoint &&
        valEndpoint == endpoint &&
        valcontract == contract)
        {
            return ETrue;     
        }
    return EFalse;    
    
}
TInt CSenInternalWsPolicy::PolicyCountL()
{
    TInt count = 0;
    CSenElement& element = AsElement();
    RPointerArray<CSenElement> list = element.ElementsL();
    CleanupClosePushL(list);
    count = list.Count();
    CleanupStack::PopAndDestroy(&list); // Close()
    return count;
    
}
TBool CSenInternalWsPolicy::UpdateMetadataEndpointL(CSenInternalWsPolicy* aInternalPolicy, TInt& aExist)
    {
//see if the New policy is in database
//&aPolicy is new Policy
//if the new policy is present and newer then the current -- we have to  replace  it
//if the new policy is present and same then the current -- check expiry - if same then no replace
//if the new policy dont have a policy then get the policy from here
//if the new policy is same (from expiry time)

    CSenWSPolicyIdentifier& newId = aInternalPolicy->IdentifierL();
    CSenWSPolicyIdentifier& id = IdentifierL();
    
    if (IsApplicableL(aInternalPolicy))
        {
            aExist = KErrNone;
            id.UpdateMetadataEndpointL(newId);
            return ETrue;
        }
        return EFalse;
    
    }

void CSenInternalWsPolicy::SetIdentifier(CSenWSPolicyIdentifier* aIdentifier)
    {
    if ( ipIdentifier )
        {
        delete ipIdentifier;
        }

    ipIdentifier = aIdentifier;
    }

CSenWSPolicyIdentifier& CSenInternalWsPolicy::IdentifierL()
    {
    if ( !ipIdentifier )
        {
        ipIdentifier = CSenWSPolicyIdentifier::NewL();
        }

    return *ipIdentifier;
    }

    
void CSenInternalWsPolicy::SetSession(CSenServiceSession& aSession)
    {
    ipSession = &aSession;
    }

CSenServiceSession* CSenInternalWsPolicy::Session()
    {
    return ipSession;
    }

TPtrC8 CSenInternalWsPolicy::ExpiryTimeL(CSenElement* aElement)
{
    if(CSenWSPolicyIdentifier::HasAttributeL(aElement, KSenWSPolicyValidUntil))
        {
        return IdentifierL().ElementAttribValueL(aElement, KSenWSPolicyValidUntil);
        }
    
    return KNullDesC8();        

}
TInt CSenInternalWsPolicy::AddMetadataPolicyL(CSenElement* aElement)
{
    if(aElement == NULL)
        return KErrArgument;
    
    TInt retVal(KErrNotFound);
    TPtrC8 metaendpoint = CWSPolicyUtils::PolicyUriL(aElement);
    TPtrC8 expiry = ExpiryTimeL(aElement);
    
    CSenElement& ele = AsElement();
    CSenElement* metaEndPointEle= IdentifierL().MetadataEndpointElementL();
    if (metaEndPointEle)
    {
        //confirm if the expiry time is greater then current time
        TTime now;
        now.UniversalTime();
        TTime validuntil = SenDateUtils::FromXmlDateTimeL(expiry);
        if(validuntil > now)
            {
            SenXmlUtils::AddAttributeL(*metaEndPointEle, KSenWSPolicyValidUntil,expiry); 
//Have to copy incase for multiple SDs have same policy
//we cannot give ownership of Policy here so create a copy and dont take ownership
            
            CSenElement* copy = CSenXmlElement::NewL(aElement->LocalName());
            copy->CopyFromL(*aElement);
            ele.AddElementL(*copy);
            retVal = KErrNone;
            }
    }

    return retVal;
}
TInt CSenInternalWsPolicy::UpdateMetadataPolicyL(CSenElement* aElement)
{

    TInt retVal(KErrNotFound);
    TPtrC8 metaendpoint = CWSPolicyUtils::PolicyUriL(aElement);
    TPtrC8 newExpiry = ExpiryTimeL(aElement);
    
    CSenElement* metaEndPointEle= IdentifierL().MetadataEndpointElementL();
             
    CSenElement& ele = AsElement();
    RPointerArray<CSenElement>& policyList = ele.ElementsL();
   
    TInt count2(policyList.Count());    //Now check for WSDL or wsp:Policy 
    for(TInt i = 0; i < count2; i++)
        {
        CSenElement* docElement = policyList[i];
        TPtrC8 currentExpiry = ExpiryTimeL(docElement);
        TPtrC8 eleName = docElement->LocalName();
        TPtrC8 eleNs = docElement->NsPrefix();
        
        if(eleName == KWsdlDocument && eleNs == KWsdlNsPrefix)
            {
            }
        else if (eleName == KPolicyDocument && eleNs == KPolicyNsPrefix)
            {
            TPtrC8 doc_metaendpoint = CWSPolicyUtils::PolicyUriL(docElement);
            
            TTime now;
            now.UniversalTime();
            TBuf8<SenDateUtils::KXmlDateTimeMaxLength> nowtime;
            TRAPD(error, SenDateUtils::ToXmlDateTimeUtf82L(nowtime, now);)
            
            if(error == KErrNone && metaEndPointEle && doc_metaendpoint == metaendpoint && 
                        newExpiry > currentExpiry &&
                        newExpiry > nowtime)
                {
                CSenElement* removed = ele.RemoveElement(*docElement);
                delete removed;
                removed = NULL;
                
                SenXmlUtils::AddAttributeL(*metaEndPointEle, KSenWSPolicyValidUntil,newExpiry); 
//Have to copy incase for multiple SDs have same policy
//we cannot give ownership of Policy here so create a copy and dont take ownership
                CSenElement* copy = CSenXmlElement::NewL(aElement->LocalName());
                copy->CopyFromL(*aElement);
                ele.AddElementL(*copy);

                retVal = KErrNone;
                return retVal;
                }
            
            }            
        }



    return retVal;
}
TInt CSenInternalWsPolicy::RemoveMetadataPolicyL(const TDesC8& aUri)
{
    TInt retVal(KErrNotFound);
    CSenElement& ele = AsElement();
    TPtrC8 endpoint = IdentifierL().MetadataEndpointL();
    if(endpoint != aUri)
    {
        return retVal;
    }
    
    CSenElement* metadataendpoint = IdentifierL().MetadataEndpointElementL();
    if (metadataendpoint)
    {
        RPointerArray<CSenElement>& policyList = ele.ElementsL();
        TInt policyCount(policyList.Count());
        for(TInt i = 0; i< policyCount; i++)
        {
            CSenElement* policy = policyList[i];
            TPtrC8 metaendpoint = CWSPolicyUtils::PolicyUriL(policy);
            if(metaendpoint == aUri)
            {
                CSenElement* removed = ele.RemoveElement(*policy);
                delete removed;
                removed = NULL;
                
                retVal = KErrNone;
                return retVal;
            }
        }
    }
    retVal = KErrNotFound;
    return retVal;
    
}
CSenElement* CSenInternalWsPolicy::WsPolicyByUriL(const TDesC8& aUri)
{
    CSenElement& ele = AsElement();
    TPtrC8 uri = IdentifierL().MetadataEndpointL();
    if(uri != aUri)
    {
        return NULL;
    }
    
    RPointerArray<CSenElement>& policyList = ele.ElementsL();
    TInt policyCount(policyList.Count());
    for(TInt i = 0; i< policyCount; i++)
    {
        CSenElement* policy = policyList[i];
        TPtrC8 metaendpoint = CWSPolicyUtils::PolicyUriL(policy);
        if(metaendpoint == aUri)
        {

            return policy;
        }
    }
    return NULL;
    
}
CSenElement* CSenInternalWsPolicy::WsPolicyByName(const TDesC8& /*aName*/)
{
/*
    CSenElement& ele = AsElement();
    RPointerArray<CSenElement> list;
    CleanupClosePushL(list);
    TInt retVal = Identifier().MetadataEndpoint(list, aUri);
    if (retVal == KErrNone)
    {
        TInt count(list.Count()); //we should al3ways have count "1"
        if(count ==1) 
        {
            RPointerArray<CSenElement>& policyList = ele.ElementsL();
            TInt policyCount(policyList.Count());
            for(TInt i = 0; i< policyCount; i++)
            {
                CSenElement* policy = policyList[i];
                TPtrC8 name = CWSPolicyUtils::PolicyNameL(policy);
                if(name == aName)
                {
                    CleanupStack::PopAndDestroy(&list);
                    return policy;
                }
                    
            }
                
        }
    }
    CleanupStack::PopAndDestroy(&list);
*/    
    return NULL;
    
}
TTime CSenInternalWsPolicy::ValidUntilL(const TDesC8& aUri)
    {
    TTime retTime = Time::NullTTime();
    TInt retVal(KErrGeneral);

    CSenElement& ele = AsElement();
    TPtrC8 uri = IdentifierL().MetadataEndpointL();
    if(uri != aUri)
    {
        return retTime;
    }
    
    CSenElement* metaEndPointEle = IdentifierL().MetadataEndpointElementL();
    if(metaEndPointEle)
    {
        TPtrC8 expiry = ExpiryTimeL(metaEndPointEle);
        if(expiry.Length() > 0)
            TRAP (retVal, retTime = SenDateUtils::FromXmlDateTimeL(expiry));
    }
    

    if(retVal != KErrNone)
        retTime = Time::NullTTime();
        
    return retTime;
    
    }


///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////



CSenWSPolicyProperties* CSenWSPolicyProperties::NewL()
    {
    CSenWSPolicyProperties* pNew = NewLC();
    CleanupStack::Pop(pNew);
    return pNew;
    }

CSenWSPolicyProperties* CSenWSPolicyProperties::NewLC()
    {
    CSenWSPolicyProperties* pNew = new (ELeave) CSenWSPolicyProperties;
    CleanupStack::PushL(pNew);
    pNew->BaseConstructL(KSenWsPolicyProperteisLocalname);
    return pNew;
    }

CSenWSPolicyProperties* CSenWSPolicyProperties::NewL(
                                            const TDesC8& aNsUri,
                                            const TDesC8& aLocalName,
                                            const TDesC8& aQName,
                                            const RAttributeArray& aAttributes)
    {
    CSenWSPolicyProperties* pNew = NewLC(aNsUri, aLocalName, aQName, aAttributes);
    CleanupStack::Pop(); // pNew;
    return pNew;
    }

CSenWSPolicyProperties* CSenWSPolicyProperties::NewLC(
                                            const TDesC8& aNsUri,
                                            const TDesC8& aLocalName,
                                            const TDesC8& aQName,
                                            const RAttributeArray& aAttributes)
    {
    CSenWSPolicyProperties* pNew = new (ELeave) CSenWSPolicyProperties;
    CleanupStack::PushL(pNew);
    pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes);
    return pNew;
    }

CSenWSPolicyProperties* CSenWSPolicyProperties::NewL(
                                            const TDesC8& aNsUri,
                                            const TDesC8& aLocalName,
                                            const TDesC8& aQName,
                                            const RAttributeArray& aAttributes,
                                            CSenElement& aParent)
    {
    CSenWSPolicyProperties* pNew = NewLC(aNsUri, aLocalName,
                                           aQName, aAttributes, aParent);
    CleanupStack::Pop(); // pNew;
    return pNew;
    }

CSenWSPolicyProperties* CSenWSPolicyProperties::NewLC(
                                            const TDesC8& aNsUri,
                                            const TDesC8& aLocalName,
                                            const TDesC8& aQName,
                                            const RAttributeArray& aAttributes,
                                            CSenElement& aParent)
    {
    CSenWSPolicyProperties* pNew = new (ELeave) CSenWSPolicyProperties;
    CleanupStack::PushL(pNew);
    pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent);
    return pNew;
    }

CSenWSPolicyProperties::~CSenWSPolicyProperties()
    {
    }

CSenWSPolicyProperties::CSenWSPolicyProperties()
    {
    }

TInt CSenWSPolicyProperties::SetPropertyL(const TDesC8& aName,
                                                         const TDesC8& aValue)
    {
    CSenElement& element = AsElement();
    RPointerArray<CSenElement> list;
    CleanupClosePushL(list);

    element.ElementsL(list, aName);

    if ( list.Count() > 0 )
        {
        CSenElement* firstElement = list[0];
        firstElement->SetContentL(aValue);
        CleanupStack::PopAndDestroy(&list); 
        
        return KErrNone;
        }
    CleanupStack::PopAndDestroy(&list);

    CSenElement& newElement = element.AddElementL(aName);
    newElement.SetContentL(aValue);
    return KErrNone;
    }

TInt CSenWSPolicyProperties::PropertyL(const TDesC8& aName, TPtrC8& aValue)
    {
    TInt retVal(KErrNone);

    CSenElement& element = AsElement();
    RPointerArray<CSenElement> list;
    CleanupClosePushL(list);

    element.ElementsL(list, aName);

    if ( list.Count() > 0 )
        {
        CSenElement* firstElement = list[0];
        if(firstElement->HasContent())
            aValue.Set(firstElement->Content());
        }
    else
        {
        retVal = KErrNotFound;
        }

    CleanupStack::PopAndDestroy(&list);
    return retVal;
    }

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

CSenWSPolicyIdentifier* CSenWSPolicyIdentifier::NewL()
    {
    CSenWSPolicyIdentifier* pNew = NewLC();
    CleanupStack::Pop(pNew);
    return pNew;
    }

CSenWSPolicyIdentifier* CSenWSPolicyIdentifier::NewLC()
    {
    CSenWSPolicyIdentifier* pNew = new (ELeave) CSenWSPolicyIdentifier;
    CleanupStack::PushL(pNew);
    pNew->BaseConstructL(KSenWsPolicyIdentifierLocalname);
    return pNew;
    }

CSenWSPolicyIdentifier* CSenWSPolicyIdentifier::NewL(
                                            const TDesC8& aNsUri,
                                            const TDesC8& aLocalName,
                                            const TDesC8& aQName,
                                            const RAttributeArray& aAttributes)
    {
    CSenWSPolicyIdentifier* pNew = NewLC(aNsUri, aLocalName, aQName, aAttributes);
    CleanupStack::Pop(); // pNew;
    return pNew;
    }

CSenWSPolicyIdentifier* CSenWSPolicyIdentifier::NewLC(
                                            const TDesC8& aNsUri,
                                            const TDesC8& aLocalName,
                                            const TDesC8& aQName,
                                            const RAttributeArray& aAttributes)
    {
    CSenWSPolicyIdentifier* pNew = new (ELeave) CSenWSPolicyIdentifier;
    CleanupStack::PushL(pNew);
    pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes);
    return pNew;
    }

CSenWSPolicyIdentifier* CSenWSPolicyIdentifier::NewL(
                                            const TDesC8& aNsUri,
                                            const TDesC8& aLocalName,
                                            const TDesC8& aQName,
                                            const RAttributeArray& aAttributes,
                                            CSenElement& aParent)
    {
    CSenWSPolicyIdentifier* pNew = NewLC(aNsUri, aLocalName,
                                           aQName, aAttributes, aParent);
    CleanupStack::Pop(); // pNew;
    return pNew;
    }

CSenWSPolicyIdentifier* CSenWSPolicyIdentifier::NewLC(
                                            const TDesC8& aNsUri,
                                            const TDesC8& aLocalName,
                                            const TDesC8& aQName,
                                            const RAttributeArray& aAttributes,
                                            CSenElement& aParent)
    {
    CSenWSPolicyIdentifier* pNew = new (ELeave) CSenWSPolicyIdentifier;
    CleanupStack::PushL(pNew);
    pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent);
    return pNew;
    }

CSenWSPolicyIdentifier::~CSenWSPolicyIdentifier()
    {
    }

CSenWSPolicyIdentifier::CSenWSPolicyIdentifier()
    {
    }

void CSenWSPolicyIdentifier::SetIdL(TInt aId)
    {
    CSenElement& element = AsElement();
    RPointerArray<CSenElement> list;
    CleanupClosePushL(list);

    element.ElementsL(list, KSenWSPolicyId);

    CSenElement* idElement;
    if ( list.Count() > 0 )
        {
        idElement = list[0];
        }
    else
        {
        idElement = &element.AddElementL(KSenWSPolicyId);
        }

    TBuf8<KFlatBufSize> buffer;
    buffer.Num(aId);
    idElement->SetContentL(buffer);

    CleanupStack::PopAndDestroy(&list); 
    }

TInt CSenWSPolicyIdentifier::IdL()
    {
    TInt retVal(KErrNotFound);

    CSenElement& element = AsElement();
    RPointerArray<CSenElement> list;
    CleanupClosePushL(list);

    element.ElementsL(list, KSenWSPolicyId);

    if ( list.Count() > 0 )
        {
        CSenElement* idElement = list[0];
        if(idElement->HasContent())
            {
            TLex8 lex;
            lex.Assign(idElement->Content());
            lex.Val( retVal );
            }
        }

    CleanupStack::PopAndDestroy(&list); 

    return retVal;
    }
TPtrC8 CSenWSPolicyIdentifier::ContractL()
{
    CSenElement& element = AsElement();
    RPointerArray<CSenElement> list;
    CleanupClosePushL(list);

    element.ElementsL(list, KContractLocalname);
    
    if ( list.Count() > 0 )
        {
        CSenElement* idElement = list[0];
        CleanupStack::PopAndDestroy(&list); 
        if(idElement->HasContent())
            return idElement->Content();
       else
            return KNullDesC8();           
        
        }

    CleanupStack::PopAndDestroy(&list); 

    return KNullDesC8();
    
}
TPtrC8 CSenWSPolicyIdentifier::EndpointL()
{
    
    CSenElement& element = AsElement();
    RPointerArray<CSenElement> list;
    CleanupClosePushL(list);

    element.ElementsL(list, KEndpointLocalname);
    
    if ( list.Count() > 0 )
        {
        CSenElement* idElement = list[0];
        CleanupStack::PopAndDestroy(&list); 
       if(idElement->HasContent())
            return idElement->Content();
       else
            return KNullDesC8();           

        }

    CleanupStack::PopAndDestroy(&list); 

    return KNullDesC8();
    
}
TPtrC8 CSenWSPolicyIdentifier::MetadataEndpointL()
{

    CSenElement& element = AsElement();
    RPointerArray<CSenElement> list;
    CleanupClosePushL(list);

    element.ElementsL(list, KMetadataEndpointLocalname);
    
    if ( list.Count() > 0 )
        {
        CSenElement* idElement = list[0];
        CleanupStack::PopAndDestroy(&list); 
       if(idElement->HasContent())
            return idElement->Content();
       else
            return KNullDesC8();           

        }

    CleanupStack::PopAndDestroy(&list); 

    return KNullDesC8();    
    
}
CSenElement* CSenWSPolicyIdentifier::MetadataEndpointElementL()
{

    CSenElement& element = AsElement();
    RPointerArray<CSenElement> list;
    CleanupClosePushL(list);

    element.ElementsL(list, KMetadataEndpointLocalname);
    
    if ( list.Count() > 0 )
        {
        CSenElement* idElement = list[0];
        CleanupStack::PopAndDestroy(&list); 
       if(idElement->HasContent())
            return idElement;
       else
            return NULL;

        }

    CleanupStack::PopAndDestroy(&list); 

    return NULL;    
    
}

TPtrC8 CSenWSPolicyIdentifier::ProviderIdL()
{

    CSenElement& element = AsElement();
    RPointerArray<CSenElement> list;
    CleanupClosePushL(list);

    element.ElementsL(list, KProviderIdLocalName);
    
    if ( list.Count() > 0 )
        {
        CSenElement* idElement = list[0];
        CleanupStack::PopAndDestroy(&list); 
       if(idElement->HasContent())
            return idElement->Content();
       else
            return KNullDesC8();           

        }

    CleanupStack::PopAndDestroy(&list); 

    return KNullDesC8();    
}
TPtrC8 CSenWSPolicyIdentifier::ElementAttribValueL(CSenElement* aElement, const TDesC8& aName)
{

    if(aElement == NULL || aName.Length() == NULL) { return KNullDesC8(); }
    
    RPointerArray<CSenBaseAttribute>& attrs = aElement->AttributesL();
    
    CSenBaseAttribute* bs = NULL;
    TInt ele_count = attrs.Count();
         
    for (TInt j=0; j < ele_count; j++)
        {
            
        bs = (attrs)[j];
        if(bs)
        {
            if(bs->Name().Compare(aName) == 0)
            {
                 return bs->Value();
            }
         }

            
        }
    return KNullDesC8();
}
TBool CSenWSPolicyIdentifier::HasAttributeL(CSenElement* aElement, const TDesC8& aName)
{
     if(aElement == NULL || aName.Length() == NULL) { return EFalse; }
    
    RPointerArray<CSenBaseAttribute>& attrs = aElement->AttributesL();
    
    CSenBaseAttribute* bs = NULL;
    TInt ele_count = attrs.Count();
         
    for (TInt j=0; j < ele_count; j++)
        {
            
        bs = (attrs)[j];
        if(bs)
        {
            if(bs->Name().Compare(aName) == 0)
            {
                 return ETrue;
            }
         }

            
        }
    return EFalse;
    
}

TInt CSenWSPolicyIdentifier::AddMetadataEndpointL(CSenElement* aElement)
{

    if(aElement == NULL || aElement->HasContent() == EFalse)
        return KErrArgument;

//get the method    
    TPtrC8 ptrMethod = ElementAttribValueL(aElement, KMetadataMethodLocalname);
//now compare the two Metadata endpoints
    CSenElement& element = AsElement();
    RPointerArray<CSenElement> list;
    CleanupClosePushL(list);
    element.ElementsL(list, aElement->LocalName());
    TInt count = list.Count();
    
    if(count == 0)    
        {
        CSenElement& newElement = element.AddElementL(aElement->LocalName());
        newElement.SetContentL(aElement->Content());
        if(ptrMethod.Length() > 0)
            SenXmlUtils::AddAttributeL(newElement, KMetadataMethodLocalname, ptrMethod);
        CleanupStack::PopAndDestroy(&list);
        return KErrNone;
        }
    
    for(TInt i = 0; i < count; i++)
        {
        CSenElement* firstElement = list[i];
        if(firstElement->Content() == aElement->Content())
            {
            
            TPtrC8 firstMethod = ElementAttribValueL(firstElement, KMetadataMethodLocalname);            
            if (ptrMethod.Compare(firstMethod) == 0 )
                {
                CleanupStack::PopAndDestroy(&list); // Close()
                //exactly Same so no need to add again                        
                return KErrNone;
                }
            }
            
        }

    CleanupStack::PopAndDestroy(&list);
    
    CSenElement& newElement = element.AddElementL(aElement->LocalName());
    newElement.SetContentL(aElement->Content());
    if(ptrMethod.Length() > 0)
        SenXmlUtils::AddAttributeL(newElement, KMetadataMethodLocalname, ptrMethod);

    return KErrNone;
    
    
}

TInt CSenWSPolicyIdentifier::UpdateMetadataEndpointL(CSenWSPolicyIdentifier& aIdentifier)
{

//now compare contents and then compare attributes
    TInt retVal = KErrNotFound;
    TPtrC8 endpoint = MetadataEndpointL();
    TPtrC8 canEndPoint = aIdentifier.MetadataEndpointL();
    if(endpoint == canEndPoint)
        {
        CSenElement* ele1 = MetadataEndpointElementL();        
        CSenElement* ele2 = aIdentifier.MetadataEndpointElementL();

        if(ele1 && ele2 && ele1->HasContent()) //&& ele2->HasContent())
        //no need to verify this as important thing is that new content has Contents
        {
            //if Endpoint URi is same
            if(ele1->Content() == ele2->Content())
                {
                if(HasAttributeL(ele1, KMetadataMethodLocalname))
                    {
                    TPtrC8 val1 =  ElementAttribValueL(ele1, KMetadataMethodLocalname);
                      
                    if(HasAttributeL(ele2, KMetadataMethodLocalname))
                        {
                        TPtrC8 val2 =  ElementAttribValueL(ele2, KMetadataMethodLocalname) ; 
                        if(val1.Compare(val2) != 0)
                            {
                            //replace the Attribute with a newer Value
                             ele2->AddAttrL(KMetadataMethodLocalname,val1);
                             retVal = KErrNone;
                            }
                        }
                    }                
                }        
        }
        }
    return retVal;
}


///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////



void RSenWSPolicyPtr::OpenL(CSenInternalWsPolicy* apPolicy)
    {
    ipPolicyData = new (ELeave) TSenWsPolicyData;
    ipPolicyData->iCounter = 1;
    ipPolicyData->ipPolicy = apPolicy;
    }
    
CSenInternalWsPolicy* RSenWSPolicyPtr::Policy()
    {
    if ( ipPolicyData )
        {
        return ipPolicyData->ipPolicy;
        }
    else
        {
        return NULL;
        }
    }
    
void RSenWSPolicyPtr::SetPolicy(CSenInternalWsPolicy* apPolicy)
    {
    if ( ipPolicyData )
        {
        delete ipPolicyData->ipPolicy;
        ipPolicyData->ipPolicy = apPolicy;
        }
    }
    
RSenWSPolicyPtr RSenWSPolicyPtr::Clone()
    {
    if ( ipPolicyData )
        {
        (ipPolicyData->iCounter)++;
        }
    return *this;
    }
    
void RSenWSPolicyPtr::Close()
    {
    if ( ipPolicyData )
        {

        (ipPolicyData->iCounter)--;
        if ( ipPolicyData->iCounter == 0 )
            {
            TRAP_IGNORE( ipPolicyData->ipPolicy->IdentifierL().ExtractElement(); )
            ipPolicyData->ipPolicy->ExtractElement();
            delete ipPolicyData->ipPolicy;
            delete ipPolicyData;
            }

        ipPolicyData = NULL;
        }
    }

void RSenWSPolicyPtr::CloseAndDestroyPolicy()
    {
    if ( ipPolicyData )
        {
        TRAP_IGNORE( ipPolicyData->ipPolicy->IdentifierL().ExtractElement(); )
        ipPolicyData->ipPolicy->ExtractElement();
        delete ipPolicyData->ipPolicy;
        ipPolicyData->ipPolicy = NULL;
        
        (ipPolicyData->iCounter)--;
        if ( ipPolicyData->iCounter == 0 )
            {
            delete ipPolicyData;
            }

        ipPolicyData = NULL;
        }
    }
    
RSenWSPolicyPtr::RSenWSPolicyPtr()
: ipPolicyData(NULL)
    {
    }

// END OF FILE