/*

* Copyright (c) 2009 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 "wsdlpolicyattachment.h"

#include "wspolicyreader.h"

#include "wspolicywriter.h"

#include "policyassertion.h"

#include "wspolicy.h"

using namespace WsdlPolicyAttachment;

EXPORT_C CWsdlPolicyAttachment* CWsdlPolicyAttachment::NewL(const TDesC8& aWsdlFileName)

    {

    CWsdlPolicyAttachment* pSelf = CWsdlPolicyAttachment::NewLC(aWsdlFileName);

    CleanupStack::Pop(pSelf);

    return pSelf;  

    }

EXPORT_C CWsdlPolicyAttachment* CWsdlPolicyAttachment::NewLC(const TDesC8& aWsdlFileName)

    {

    CWsdlPolicyAttachment* pSelf = new (ELeave) CWsdlPolicyAttachment();

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL(aWsdlFileName);

    return pSelf;  

    }

CWsdlPolicyAttachment::~CWsdlPolicyAttachment()

    {

    iOriginalPolicies.Reset();

    iNormalizedPolicies.Reset();

    if( iRegistry )

        {

        iRegistry->ResetRegistry();

        }

    delete iRegistry;

    }

void CWsdlPolicyAttachment::ConstructL(const TDesC8& aWsdlFileName)

    {

    iRegistry = CPolicyRegistry::NewL();

    CreateWsdlPolicyL( aWsdlFileName );

    }

CWsdlPolicyAttachment::CWsdlPolicyAttachment() :

iOriginalPolicies(ETrue,ETrue),

iNormalizedPolicies(ETrue, ETrue), 

iParsed(EFalse)

    {

    }

void CWsdlPolicyAttachment::CreateWsdlPolicyL( const TDesC8& aWsdlContent )

    {

    TInt size = aWsdlContent.Length();

    if(size > 0)

        {

        iXmlReader = CSenXmlReader::NewL( KXmlParserMimeType ); // use libxml2 sax parser + CodeScannerWarnings     

        TRAPD (err, ParseL( aWsdlContent )); 

        delete iXmlReader;

        iXmlReader = NULL;

        if(err == KErrNone)

            {

            iParsed = ETrue;

            iPolicy = &AsElement(); 

            iRegistry->PopulateRegistryL(iPolicy);   

            }

        }   

}

TPtrC8 CWsdlPolicyAttachment::GetAttributeValueL(const TDesC8& aAttribute, CSenElement* aElement)

{

    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(aAttribute) == 0)

            {

             return bs->Value();

            }

         }

    return KNullDesC8();

}

EXPORT_C CSenElement* CWsdlPolicyAttachment::GetEffectiveServicePolicyL( const TDesC8& aService )

    {

    //wsdl:service

    CSenElement* pServicePolicy = GetServicePolicyL( aService );

    RPointerArray<CSenElement> array;

    CleanupClosePushL( array );

    if( pServicePolicy )

        {

        array.Append( pServicePolicy );

        }

    CWSPolicy* pol = GetEffectivePolicyL( array, iRegistry );

    CleanupStack::PopAndDestroy( &array ); //array.Close();    

    //CSenElement* policy = NULL;

    //return policy;

    return NULL;

    }

EXPORT_C CSenElement* CWsdlPolicyAttachment::GetEffectiveEndpointPolicyL( 

    const TDesC8& aService, 

    const TDesC8& aPort )

{

    //wsdl:port

    //wsdl:portType

    //wsdl:binding

    CSenElement* portPolicy = GetPortPolicyL(aService, aPort);

    RPointerArray<CSenElement> array;

    CleanupClosePushL( array );

    if( portPolicy )

        {

        array.Append(portPolicy);

        }

    CSenElement* portTypePolicy = GetPortTypePolicyL(aService, aPort);

    if(portTypePolicy)

        {

        array.Append(portTypePolicy);    

        }

    CSenElement* bindingPolicy = GetBindingPolicyL(aService, aPort);

    if(bindingPolicy)

        {

        array.Append(bindingPolicy);

        }

    // (!) Merge these policies to get effective one:

    CWSPolicy* pol = GetEffectivePolicyL(array, iRegistry); //merge these policies to get effective one

    if( pol )

        {

        // Serialize into file: 

        RFs fss;

        User::LeaveIfError(fss.Connect());

        CleanupClosePushL(fss);

        CSenElement* poli = pol->PolicyL();

        _LIT( KFileNameOut, "c:\\logs\\WsSecurity10Sign.svc.xml");        

        HBufC8* temp = poli->AsXmlL();

        CleanupStack::PushL(temp);

        TFileName iFileName12(KFileNameOut);

        RFile  xmlFilew;

        xmlFilew.Replace(fss , iFileName12, EFileWrite );

        xmlFilew.Write(temp->Des());

        xmlFilew.Close();

        CleanupStack::PopAndDestroy(temp);    

        CleanupStack::PopAndDestroy(&fss);

        }    

    CleanupStack::PopAndDestroy( &array ); // array.Close();

    return NULL;    

    }

EXPORT_C CSenElement* CWsdlPolicyAttachment::GetEffectiveOperationPolicyL( const TDesC8& aService, 

                                                                           const TDesC8& aPortName, 

                                                                           const TDesC8& aOpName )

    {

    // wsdl:portType/wsdl:operation

    // wsdl:binding/wsdl:operation

    CSenElement* portTypePolicy = GetPortTypeOperationPolicyL(aService, aPortName, aOpName);

    RPointerArray<CSenElement> array;

    CleanupClosePushL( array );

    if(portTypePolicy)

        {

        array.Append(portTypePolicy);    

        }

    CSenElement* bindingPolicy = GetBindingOperationPolicyL(aService, aPortName, aOpName);

    if(bindingPolicy)

        {

        array.Append(bindingPolicy);    

        }

    // (!) Merge these policies to get effective one:

    GetEffectivePolicyL(array, iRegistry);

    CleanupStack::PopAndDestroy( &array ); // array.Close();

    // CSenElement* policy = NULL;

    // return policy;  

    return NULL;

    }

EXPORT_C CSenElement* CWsdlPolicyAttachment::GetEffectiveInputPolicyL(const TDesC8& aService, const TDesC8& aPortName, const TDesC8& aOpName)

    {

    // wsdl:message

    // wsdl:portType/wsdl:operation/wsdl:input

    // wsdl:binding/wsdl:operation/wsdl:input

    CSenElement* messagePolicy = GetMessagePolicyL(aService, aPortName, aOpName, ETrue);

    RPointerArray<CSenElement> array;

    CleanupClosePushL( array );

    if( messagePolicy )

        {

        array.Append(messagePolicy);

        }

    CSenElement* portTypePolicy = GetPortTypeOperationInputOutputPolicyL(aService, aPortName, aOpName, ETrue);

    if( portTypePolicy )

        {

        array.Append(portTypePolicy);        

        }

    CSenElement* bindingPolicy = GetBindingOperationInputOutputPolicyL(aService, aPortName, aOpName, ETrue);

    if( bindingPolicy )

        {

        array.Append(bindingPolicy);    

        }

    // (!) Merge these policies to get effective one:

    GetEffectivePolicyL(array, iRegistry); 

    CleanupStack::PopAndDestroy( &array ); // array.Close();

    //CSenElement* policy = NULL;

    //return policy;  

    return NULL;

    }

EXPORT_C CSenElement* CWsdlPolicyAttachment::GetEffectiveOutputPolicyL(const TDesC8& aService, const TDesC8& aPortName, const TDesC8& aOpName)

    {

    // wsdl:message

    // wsdl:portType/wsdl:operation/wsdl:output

    // wsdl:binding/wsdl:operation/wsdl:output

    CSenElement* messagePolicy = GetMessagePolicyL(aService, aPortName, aOpName, EFalse);

    RPointerArray<CSenElement> array;

    if( messagePolicy )

        {

        array.Append(messagePolicy);        

        }

    CSenElement* portTypePolicy = GetPortTypeOperationInputOutputPolicyL(aService, aPortName, aOpName, EFalse);

    if( portTypePolicy )

        {

        array.Append(portTypePolicy);    

        }

    CSenElement* bindingPolicy = GetBindingOperationInputOutputPolicyL(aService, aPortName, aOpName, EFalse);

    if( bindingPolicy )

        {

        array.Append(bindingPolicy);    

        }

    // (!) Merge these policies to get effective one:

    GetEffectivePolicyL( array, iRegistry );

    CleanupStack::PopAndDestroy( &array ); // array.Close();

    // CSenElement* policy = NULL;

    // return policy;  

    return NULL;

}

EXPORT_C CSenElement* CWsdlPolicyAttachment::GetEffectiveFaultPolicyL( /*QName aService, */

                                                                        const TDesC8& /*aPortName*/, 

                                                                        const TDesC8& /*aOpName*/ )

    { 

    // wsdl:message

    // wsdl:portType/wsdl:operation/wsdl:fault

    // wsdl:binding/wsdl:operation/wsdl:fault

      return NULL;

    }

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

//PRIVATE FUNCTIONS

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

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

CSenElement* CWsdlPolicyAttachment::GetServicePolicyL( const TDesC8& aServiceName )

    {

    //    RPointerArray<CSenElement>& list = iPolicy->ElementsL(); //get the definitions elements

    //    TInt count = list.Count();

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

    //    {

    //        CSenElement* definitions = list[i];

    //        TPtrC8 localName = definitions->LocalName();

    RPointerArray<CSenElement> serviceList;     // get the wsdl:service

    iPolicy->ElementsL(serviceList, KService); //KWsdlNsUri, KService);

    CleanupClosePushL( serviceList );

    TInt count2 = serviceList.Count();

    for( TInt j = 0; j< count2; j++ )

        {

        CSenElement* service = serviceList[j];

        TPtrC8 localServiceName = service->LocalName();

        TPtrC8 serviceName  = GetAttributeValueL(KName, service);

        if(serviceName != KNullDesC8())

            {

            if (serviceName.Compare(aServiceName) == 0)

                { //we have right service tag, search its children for PolicyReference

                    serviceList.Close();

                    return GetPolicyReferenceL(service);

                }

            }

        }

    CleanupStack::PopAndDestroy( &serviceList ); // serviceList.Close();

    return NULL;

    }

CSenElement* CWsdlPolicyAttachment::GetPortPolicyL(const TDesC8& aServiceName, const TDesC8& aPort)

    {

    CSenElement* result = GetServiceElementL(aServiceName);

    if (result)

        {

        result = GetPortElementL(aPort, result);

        if (result)

            {

            return GetPolicyReferenceL(result);

            }

        }

    return NULL;  

    }

CSenElement* CWsdlPolicyAttachment::GetPortTypePolicyL( const TDesC8& aServiceName, 

                                                        const TDesC8& aPort )

    {

    //from service get port

    //from port get binding

    //from binding get porttype

    CSenElement* result = GetServiceElementL(aServiceName);

    if (result)

        {

        result = GetPortElementL(aPort, result);

        if (result)

            {   

            // get binding from port 

            TPtrC8 bindingQName = GetAttributeValueL(KBinding, result);

            TPtrC8 bindingPrefix = bindingQName.Left(bindingQName.Find(KColon));

            TPtrC8 bindingName = bindingQName.Right(bindingQName.Length() - bindingPrefix.Length()-1);

            result = GetBindingElementL(bindingName);

            if(result)    

                {

                //we got the right binding, now get the portType

                TPtrC8 portTypeQName = GetAttributeValueL(KType, result); 

                //actually this is buinding type

                TPtrC8 portTypePrefix = portTypeQName.Left(portTypeQName.Find(KColon));

                TPtrC8 portTypeName = portTypeQName.Right(portTypeQName.Length() - portTypePrefix.Length()-1);

                //here we have port Name

                //now look for this port type in wsdl

                result = GetPortTypeElementL(portTypeName);

                if(result)

                    {

                    return GetPolicyReferenceL(result);

                    }

                else

                    {

                    return NULL;

                    }

                }

            }

        }

    return NULL;

    }

CSenElement* CWsdlPolicyAttachment::GetBindingPolicyL( const TDesC8& aServiceName, 

                                                       const TDesC8& aPort )

    {

    //the aBindingName is obtained from the port operation. 

    //so Use that Name and then jsut search for that particualr binding

    CSenElement* result = GetServiceElementL(aServiceName);

    if (result)

        {

        result = GetPortElementL(aPort, result);

        if (result)

            {   

            // get binding from port and

            TPtrC8 bindingQName = GetAttributeValueL(KBinding, result);

            TPtrC8 bindingPrefix = bindingQName.Left(bindingQName.Find(KColon));

            TPtrC8 bindingName = bindingQName.Right(bindingQName.Length() - bindingPrefix.Length()-1);

            result = GetBindingElementL(bindingName);

            if( result )    

                {

                //we got the right binding, now get the policy

                result = GetPolicyReferenceL( result );

                //if ( result ) 

                //    //we got a policy TAG for the binding

                // { 

                return result; 

                }

            }

        }

    return NULL;

    }

CSenElement* CWsdlPolicyAttachment::GetPortTypeOperationPolicyL( const TDesC8& aServiceName, const TDesC8& aPort, const TDesC8& aOpName )

    {

    CSenElement* result = GetServiceElementL(aServiceName);

    if ( result )

        {

        result = GetPortElementL(aPort, result);

        if ( result )

            {

            // get binding from port and

            TPtrC8 bindingQName = GetAttributeValueL(KBinding, result);

            TPtrC8 bindingPrefix = bindingQName.Left(bindingQName.Find(KColon));

            TPtrC8 bindingName = bindingQName.Right(bindingQName.Length() - bindingPrefix.Length()-1);

            result = GetBindingElementL(bindingName);

            if( result )

                {

                // we got the right binding, now get the portType

                TPtrC8 portTypeQName = GetAttributeValueL(KType, result); 

                //actually this is buinding type

                TPtrC8 portTypePrefix = portTypeQName.Left(portTypeQName.Find(KColon));

                TPtrC8 portTypeName = portTypeQName.Right(portTypeQName.Length() - portTypePrefix.Length()-1);

                // here we have port Name

                // now look for this port type in wsdl

                result = GetPortTypeElementL( portTypeName );

                if( result ) //we got the portType

                    {

                    // now get the operation in this element

                    result = GetOperationPolicyL( aOpName, result );

                    return result;

                    }

                }

            }

        }

    return NULL;

    }

CSenElement* CWsdlPolicyAttachment::GetBindingOperationPolicyL( const TDesC8& aServiceName, const TDesC8& aPort, const TDesC8& aOpName )

    {

    CSenElement* result = GetServiceElementL(aServiceName);

    if ( result )

        {

        result = GetPortElementL(aPort, result);

        if ( result )

            {   

            //get binding from port and

            TPtrC8 bindingQName = GetAttributeValueL(KBinding, result);

            TPtrC8 bindingPrefix = bindingQName.Left(bindingQName.Find(KColon));

            TPtrC8 bindingName = bindingQName.Right(bindingQName.Length() - bindingPrefix.Length()-1);

            result = GetBindingElementL(bindingName);

            if(result)    //we got the right binding, 

                // now get the OperationPolicy from this binding

                {

                result = GetOperationPolicyL(aOpName, result);   

                return result;

                }

            }

        }

    return NULL;

    }

CSenElement* CWsdlPolicyAttachment::GetOperationPolicyL( const TDesC8& aOpName, 

                                                         CSenElement* aElement )

    {

    RPointerArray<CSenElement> operationList;        

    aElement->ElementsL(operationList, KWsdlNsUri, KOperation);

    CleanupClosePushL( operationList );

    TInt count = operationList.Count();

    CSenElement* result = NULL;

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

        {

        CSenElement* operation = operationList[i];

        TPtrC8 operationName = GetAttributeValueL(KName, operation);

        if(operationName.Compare(aOpName) == 0)

            {

            //we got the rigth operation element

            //now retrieve policy from this element

            result = GetPolicyReferenceL(operation);

            //if( result ) 

            //    {

            //    //we got a policy TAG for the binding

            //    

            //    }

            }

        }

    CleanupStack::PopAndDestroy( &operationList ); // operationList.Close();

    return result;

    }

CSenElement* CWsdlPolicyAttachment::GetMessagePolicyL( const TDesC8& aServiceName, 

                                                       const TDesC8& aPort, 

                                                       const TDesC8& aOpName, TBool aInput )

    {

    CSenElement* result = GetServiceElementL(aServiceName);

    if ( result )

        {

        result = GetPortElementL(aPort, result);

        if ( result )

            {   

            //get binding from port and

            TPtrC8 bindingQName = GetAttributeValueL(KBinding, result);

            TPtrC8 bindingPrefix = bindingQName.Left(bindingQName.Find(KColon));

            TPtrC8 bindingName = bindingQName.Right(bindingQName.Length() - bindingPrefix.Length()-1);

            result = GetBindingElementL(bindingName);

            if( result )    

                {

                // we got the right binding, now get the Operation from this binding                     

                // if aInput == ETrue then its Input policy else its output policy

                // we get binding now find the input/output for that aOpName

                RPointerArray<CSenElement> operationList;

                result->ElementsL(operationList, KWsdlNsUri, KOperation);

                CleanupClosePushL(operationList);

                TInt count = operationList.Count();

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

                    {

                    CSenElement* operation = operationList[i];

                    TPtrC8 operationName = GetAttributeValueL(KName, operation);

                    if(operationName.Compare(aOpName) == 0)

                        {

                        //we got the rigth operation element

                        //now retrieve input/output element

                        RPointerArray<CSenElement> operationInOutList;

                        CleanupClosePushL(operationInOutList);

                        if(aInput)

                            {

                            operation->ElementsL(operationInOutList, KWsdlNsUri, KInput);

                            }

                        else

                            {

                            operation->ElementsL(operationInOutList, KWsdlNsUri, KOutput);

                            }

                        TInt operationListCount = operationInOutList.Count();

                        for( TInt j = 0; j< operationListCount; j++ )

                            {