diff -r 000000000000 -r 62f9d29f7211 webservices/idwsfplugin/src/idwsfdsqueryresponse.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/webservices/idwsfplugin/src/idwsfdsqueryresponse.cpp Thu Jan 07 16:19:19 2010 +0200 @@ -0,0 +1,411 @@ +/* +* 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 +#include +#include // check if this include is needed(?) +#include +#include + +#include "idwsfdsqueryresponse.h" +#include "sendebug.h" + + +namespace + { + _LIT8(KOkLowerCase, "ok"); + _LIT8(KOkUpperCase, "OK"); + + _LIT8(KResourceIdName, "ResourceID"); + _LIT8(KResourceOfferingName, "ResourceOffering"); + _LIT8(KServiceInstanceName, "ServiceInstance"); + _LIT8(KEncryptedResourceIdName, "EncryptedResourceID"); + _LIT8(KProviderIdName, "ProviderID"); + _LIT8(KCredentialRefName, "CredentialRef"); + _LIT8(KServiceTypeName, "ServiceType"); + _LIT8(KOptionName, "Option"); + + _LIT8(KVal_NotOnOrAfter, "NotOnOrAfter"); + + _LIT8(KDescriptionElementLocalName, "Description"); + } + +CIdWsfDsQueryResponse* CIdWsfDsQueryResponse::NewL() + { + CIdWsfDsQueryResponse* pNew = NewLC(); + CleanupStack::Pop(); // pNew; + return pNew; + } + +CIdWsfDsQueryResponse* CIdWsfDsQueryResponse::NewLC() + { + CIdWsfDsQueryResponse* pNew = new (ELeave) CIdWsfDsQueryResponse; + CleanupStack::PushL(pNew); + pNew->BaseConstructL(); + return pNew; + } + + +CIdWsfDsQueryResponse* CIdWsfDsQueryResponse::NewL( + const TDesC8& aNsUri, + const TDesC8& aLocalName, + const TDesC8& aQName + ) + { + CIdWsfDsQueryResponse* pNew = NewLC( aNsUri, aLocalName, aQName ); + CleanupStack::Pop(); // pNew; + return pNew; + } + +CIdWsfDsQueryResponse* CIdWsfDsQueryResponse::NewLC( + const TDesC8& aNsUri, + const TDesC8& aLocalName, + const TDesC8& aQName + ) + { + CIdWsfDsQueryResponse* pNew = new (ELeave) CIdWsfDsQueryResponse; + CleanupStack::PushL(pNew); + pNew->BaseConstructL(aNsUri, aLocalName, aQName); + return pNew; + } + + +CIdWsfDsQueryResponse::CIdWsfDsQueryResponse() +: ipResourceOffering(NULL), + ipCredential(NULL), + ipServiceInstance(NULL) + { + } + +void CIdWsfDsQueryResponse::BaseConstructL() + { + CSenBaseFragment::BaseConstructL( + KQueryResponseXmlns, + KQueryResponseName, + KQueryResponseQName + ); + } + +void CIdWsfDsQueryResponse::BaseConstructL( + const TDesC8& aNsUri, + const TDesC8& aLocalName, + const TDesC8& aQName + ) + { + CSenBaseFragment::BaseConstructL(aNsUri, aLocalName, aQName); + iNotOnOrAfter = Time::NullTTime(); + } + +CIdWsfDsQueryResponse::~CIdWsfDsQueryResponse() + { + delete ipStatus; + iResourceOfferings.ResetAndDestroy(); + + // should be NULL if appended to iResourceOfferings: + delete ipResourceOffering; + delete ipCredential; + delete ipServiceInstance; + } + +void CIdWsfDsQueryResponse::GetAllServicesL( + RPointerArray& aDest ) + { + // Return all CIdWsfServiceInstance's + for (TInt i = 0; i < iResourceOfferings.Count(); i++) + { + RPointerArray& services = + iResourceOfferings[i]->ServicesL(); + for (TInt j = 0; j < services.Count(); j++) + { + User::LeaveIfError(aDest.Append(services[j])); + } + } + } + +void CIdWsfDsQueryResponse::StartElementL( + const TDesC8& aNsUri, + const TDesC8& aLocalName, + const TDesC8& aQName, + const RAttributeArray& aAttributes + ) + { + switch (iState) + { + case KStateIgnore: + { + SaveNamespacesL(aAttributes, EFalse); + + // we are interested in the Status element + if (aLocalName == KStatusName) + { + // we should save the status code + HBufC8* pNew = + SenXmlUtils::AllocAttrValueL(aAttributes, + KStatusCodeName); + delete ipStatus; + ipStatus = pNew; + } + + // we are interested in ResourceOffering + else if (aLocalName == KResourceOfferingName) + { + // odd state: starts saving content + iState = KStateParsingResourceOffering; + ipResourceOffering = CIdWsfResourceOffering::NewL(); + } + + //or in a Credentials + else if (aLocalName == KCredentialsName) + { + iState = KStateParsingCredentials; + TPtrC8 ptr = SenXmlUtils::AttrValue(aAttributes, + KVal_NotOnOrAfter); + if (ptr.Length()>0) + { + iNotOnOrAfter = SenDateUtils::FromXmlDateTimeL(ptr); + } + } + break; + } + case KStateParsingResourceOffering: + { + // We clean the buffer so that we can save the element content + // At endElement we will know what member of the resource offering + // to set. + ResetContentL(); + // save namespace declarations and ensure that all local prefixes + // are noted. + SaveNamespacesL(aAttributes, ETrue); + if (aLocalName == KServiceInstanceName) + { + // if this is second RO, delete the ipServiceInstance made + // ready + // previous RO's possible (but not encountered) next service + // instance. + // bugfix 2004-11-09 + if(ipServiceInstance) + { + delete ipServiceInstance; + ipServiceInstance = NULL; + } + + ipServiceInstance = CIdWsfServiceInstance::NewL(); + } + if (aLocalName == KEncryptedResourceIdName) + { + iState = KStateParsingEncryptedResourceId; + } + break; + } + case KStateParsingEncryptedResourceId: + { + AllocContentSaverL(); + WriteStartElementL(aNsUri, aLocalName, aQName, aAttributes); + break; + } + case KStateParsingCredentials: + { + CSenCredential* pCredential = CSenCredential::NewL( + aNsUri, aLocalName, aQName, aAttributes, AsElement()); + + CleanupStack::PushL(pCredential); // bugfix 2004-08-09 + + if (iNotOnOrAfter != Time::NullTTime()) + { + pCredential->SetValidUntil(iNotOnOrAfter); + } + + delete ipCredential; + ipCredential = pCredential; + CleanupStack::Pop(); // class owns the pCredential now.. + DelegateParsingL(*ipCredential); + iState = KStateParsingSingleCredential; + break; + } + default: + { + break; + } + } + } + +void CIdWsfDsQueryResponse::EndElementL( + const TDesC8& aNsUri, + const TDesC8& aLocalName, + const TDesC8& aQName) + { + switch(iState) + { + case KStateParsingResourceOffering: + { + if (aLocalName == KResourceOfferingName) + { + User::LeaveIfError( + iResourceOfferings.Append(ipResourceOffering)); + ipResourceOffering = NULL; + iState = KStateIgnore; + } + else if (aLocalName == KResourceIdName || + aLocalName == KEncryptedResourceIdName) + { + ipResourceOffering->SetResourceIdL(Content()); + } + + else if (aLocalName == KDescriptionElementLocalName) + { + ipResourceOffering->AddServiceInstanceL(ipServiceInstance); + + // alloc new instance for the next parsing cycle + ipServiceInstance = + CIdWsfServiceInstance::NewL(*ipServiceInstance); + break; + } + else + { + if (aLocalName == KProviderIdName) + { + ipServiceInstance->SetProviderIdL(Content()); + break; + } + else if (aLocalName == KSecurityMechIdName) + { + ipServiceInstance->AddSecurityMechL(Content()); + break; + } + else if (aLocalName == KCredentialRefName) + { + ipServiceInstance->AddCredentialRefL(Content()); + break; + } + else if (aLocalName == KEndpointName) + { + ipServiceInstance->SetEndPointL(Content()); + break; + } + else if (aLocalName == KServiceTypeName) + { + ipServiceInstance->SetServiceTypeL(Content()); + break; + } + else if (aLocalName == KOptionName) + { + CSenFacet* pFacet = CSenFacet::NewL(); + CleanupStack::PushL( pFacet ); + pFacet->SetNameL(Content()); + pFacet->SetTypeL(KDiscoOption); + ipResourceOffering->SetFacetL(*pFacet); + CleanupStack::PopAndDestroy( pFacet ); // SetFacetL does not take ownership but makes a copy of the facet insteadfs + break; + } + } + break; + } + case KStateParsingEncryptedResourceId: + { + if (aLocalName == KResourceIdName || + aLocalName == KEncryptedResourceIdName) + { + ipResourceOffering->SetResourceIdL(Content()); + iState = KStateParsingResourceOffering; + } + else WriteEndElementL(aNsUri, aLocalName, aQName); + break; + } + case KStateParsingCredentials: + { + if (aLocalName == KCredentialsName) + { + iNotOnOrAfter = Time::NullTTime(); + iState = KStateIgnore; + } + break; + } + case KStateParsingSingleCredential: + { + + HBufC8* pAsXml = ipCredential->AsXmlL(); + CleanupStack::PushL(pAsXml); + const TDesC8& refId = ipCredential->Id(); + + if(pAsXml && refId.Length()>0) + { + ipCredential->DetachL(); + + TInt count(iResourceOfferings.Count()); + for (TInt i = 0; i < count; i++) + { + iResourceOfferings[i]->AddCredentialL(*ipCredential); + } + delete ipCredential; + } + else + delete ipCredential; // ownership was _not_ transferred(!), + // forced to delete here + + CleanupStack::PopAndDestroy(); // pAsXml; + + ipCredential = NULL; + iState = KStateParsingCredentials; + break; + } + default: // corresponds with ref-impl (Java) having case + // BaseFragment.IGNORE: break; + { + break; + } + } + } + +TBool CIdWsfDsQueryResponse::IsOk() + { + if (!ipStatus) + { + return EFalse; + } + else + { + return (SenXmlUtils::EndsWith(*ipStatus, KOkLowerCase) || + SenXmlUtils::EndsWith(*ipStatus, KOkUpperCase)); + } + } + +// returns the first one (oldest) added.. +TPtrC8 CIdWsfDsQueryResponse::ResourceId() + { + if (iResourceOfferings.Count() > 0) + { + return iResourceOfferings[0]->ResourceId(); + } + else + { + return NULL; + } + } + +RPointerArray& + CIdWsfDsQueryResponse::ResourceOfferingsL() + { + return iResourceOfferings; + }