webservices/idwsfplugin/src/idwsfdsqueryresponse.cpp
changeset 0 62f9d29f7211
equal deleted inserted replaced
-1:000000000000 0:62f9d29f7211
       
     1 /*
       
     2 * Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies). 
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:        
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 
       
    20 
       
    21 
       
    22 
       
    23 
       
    24 
       
    25 // INCLUDE FILES
       
    26 #include <SenDateUtils.h>
       
    27 #include <SenFacet.h>
       
    28 #include <SenXmlElement.h> // check if this include is needed(?)
       
    29 #include <SenXmlUtils.h>
       
    30 #include <SenCredential.h>
       
    31 
       
    32 #include "idwsfdsqueryresponse.h"
       
    33 #include "sendebug.h"
       
    34 
       
    35 
       
    36 namespace
       
    37     {
       
    38     _LIT8(KOkLowerCase, "ok");
       
    39     _LIT8(KOkUpperCase, "OK");
       
    40 
       
    41     _LIT8(KResourceIdName, "ResourceID");
       
    42     _LIT8(KResourceOfferingName, "ResourceOffering");
       
    43     _LIT8(KServiceInstanceName, "ServiceInstance");
       
    44     _LIT8(KEncryptedResourceIdName, "EncryptedResourceID");
       
    45     _LIT8(KProviderIdName, "ProviderID");
       
    46     _LIT8(KCredentialRefName, "CredentialRef");
       
    47     _LIT8(KServiceTypeName, "ServiceType");
       
    48     _LIT8(KOptionName, "Option");
       
    49 
       
    50     _LIT8(KVal_NotOnOrAfter, "NotOnOrAfter");
       
    51 
       
    52     _LIT8(KDescriptionElementLocalName, "Description");
       
    53     }
       
    54 
       
    55 CIdWsfDsQueryResponse* CIdWsfDsQueryResponse::NewL()
       
    56     {
       
    57     CIdWsfDsQueryResponse* pNew = NewLC();
       
    58     CleanupStack::Pop(); // pNew;
       
    59     return pNew;
       
    60     }
       
    61 
       
    62 CIdWsfDsQueryResponse* CIdWsfDsQueryResponse::NewLC()
       
    63     {
       
    64     CIdWsfDsQueryResponse* pNew = new (ELeave) CIdWsfDsQueryResponse;
       
    65     CleanupStack::PushL(pNew);
       
    66     pNew->BaseConstructL();
       
    67     return pNew;
       
    68     }
       
    69 
       
    70 
       
    71 CIdWsfDsQueryResponse* CIdWsfDsQueryResponse::NewL(
       
    72     const TDesC8& aNsUri,
       
    73     const TDesC8& aLocalName,
       
    74     const TDesC8& aQName
       
    75     )
       
    76     {
       
    77     CIdWsfDsQueryResponse* pNew = NewLC( aNsUri, aLocalName, aQName );
       
    78     CleanupStack::Pop(); // pNew;
       
    79     return pNew;
       
    80     }
       
    81 
       
    82 CIdWsfDsQueryResponse* CIdWsfDsQueryResponse::NewLC(
       
    83     const TDesC8& aNsUri,
       
    84     const TDesC8& aLocalName,
       
    85     const TDesC8& aQName
       
    86     )
       
    87     {
       
    88     CIdWsfDsQueryResponse* pNew = new (ELeave) CIdWsfDsQueryResponse;
       
    89     CleanupStack::PushL(pNew);
       
    90     pNew->BaseConstructL(aNsUri, aLocalName, aQName);
       
    91     return pNew;
       
    92     }
       
    93 
       
    94 
       
    95 CIdWsfDsQueryResponse::CIdWsfDsQueryResponse()
       
    96 : ipResourceOffering(NULL),
       
    97   ipCredential(NULL),
       
    98   ipServiceInstance(NULL)
       
    99     {
       
   100     }
       
   101 
       
   102 void CIdWsfDsQueryResponse::BaseConstructL()
       
   103     {
       
   104     CSenBaseFragment::BaseConstructL(
       
   105         KQueryResponseXmlns,
       
   106         KQueryResponseName,
       
   107         KQueryResponseQName
       
   108         );
       
   109     }
       
   110 
       
   111 void CIdWsfDsQueryResponse::BaseConstructL(
       
   112     const TDesC8& aNsUri,
       
   113     const TDesC8& aLocalName,
       
   114     const TDesC8& aQName
       
   115     )
       
   116     {
       
   117     CSenBaseFragment::BaseConstructL(aNsUri, aLocalName, aQName);
       
   118     iNotOnOrAfter = Time::NullTTime();
       
   119     }
       
   120 
       
   121 CIdWsfDsQueryResponse::~CIdWsfDsQueryResponse()
       
   122     {
       
   123     delete ipStatus;
       
   124     iResourceOfferings.ResetAndDestroy();
       
   125 
       
   126     // should be NULL if appended to iResourceOfferings:
       
   127     delete ipResourceOffering;
       
   128     delete ipCredential;
       
   129     delete ipServiceInstance;
       
   130     }
       
   131 
       
   132 void CIdWsfDsQueryResponse::GetAllServicesL(
       
   133         RPointerArray<CIdWsfServiceInstance>& aDest )
       
   134     {
       
   135     // Return all CIdWsfServiceInstance's
       
   136     for (TInt i = 0; i < iResourceOfferings.Count(); i++)
       
   137         {
       
   138         RPointerArray<CIdWsfServiceInstance>& services =
       
   139             iResourceOfferings[i]->ServicesL();
       
   140         for (TInt j = 0; j < services.Count(); j++)
       
   141             {
       
   142             User::LeaveIfError(aDest.Append(services[j]));
       
   143             }
       
   144         }
       
   145     }
       
   146 
       
   147 void CIdWsfDsQueryResponse::StartElementL(
       
   148     const TDesC8& aNsUri,
       
   149     const TDesC8& aLocalName,
       
   150     const TDesC8& aQName,
       
   151     const RAttributeArray& aAttributes
       
   152     )
       
   153     {
       
   154     switch (iState)
       
   155         {
       
   156         case KStateIgnore:
       
   157             {
       
   158             SaveNamespacesL(aAttributes, EFalse);
       
   159 
       
   160             // we are interested in the Status element
       
   161             if (aLocalName == KStatusName)
       
   162                 {
       
   163                 // we should save the status code
       
   164                 HBufC8* pNew =
       
   165                     SenXmlUtils::AllocAttrValueL(aAttributes, 
       
   166                                                     KStatusCodeName);
       
   167                 delete ipStatus;
       
   168                 ipStatus = pNew;
       
   169                 }
       
   170 
       
   171             // we are interested in ResourceOffering
       
   172             else if (aLocalName == KResourceOfferingName)
       
   173                 {
       
   174                 // odd state: starts saving content
       
   175                 iState = KStateParsingResourceOffering;
       
   176                 ipResourceOffering = CIdWsfResourceOffering::NewL();
       
   177                 }
       
   178 
       
   179             //or in a Credentials
       
   180             else if (aLocalName == KCredentialsName)
       
   181                 {
       
   182                 iState = KStateParsingCredentials;
       
   183                 TPtrC8 ptr = SenXmlUtils::AttrValue(aAttributes, 
       
   184                                                     KVal_NotOnOrAfter);
       
   185                 if (ptr.Length()>0)
       
   186                     {
       
   187                     iNotOnOrAfter = SenDateUtils::FromXmlDateTimeL(ptr);
       
   188                     }
       
   189                 }
       
   190             break;
       
   191             }
       
   192         case KStateParsingResourceOffering:
       
   193             {
       
   194             // We clean the buffer so that we can save the element content
       
   195             // At endElement we will know what member of the resource offering
       
   196             // to set.
       
   197             ResetContentL();
       
   198             // save namespace declarations and ensure that all local prefixes
       
   199             // are noted.
       
   200             SaveNamespacesL(aAttributes, ETrue);
       
   201             if (aLocalName == KServiceInstanceName)
       
   202                 {
       
   203                 // if this is second RO, delete the ipServiceInstance made
       
   204                 // ready
       
   205                 // previous RO's possible (but not encountered) next service
       
   206                 // instance.
       
   207                 // bugfix 2004-11-09
       
   208                 if(ipServiceInstance)
       
   209                     {
       
   210                     delete ipServiceInstance;
       
   211                     ipServiceInstance = NULL;
       
   212                     }
       
   213 
       
   214                 ipServiceInstance = CIdWsfServiceInstance::NewL();
       
   215                 }
       
   216             if (aLocalName == KEncryptedResourceIdName)
       
   217                 {
       
   218                 iState = KStateParsingEncryptedResourceId;
       
   219                 }
       
   220             break;
       
   221             }
       
   222         case KStateParsingEncryptedResourceId:
       
   223             {
       
   224             AllocContentSaverL();
       
   225             WriteStartElementL(aNsUri, aLocalName, aQName, aAttributes);
       
   226             break;
       
   227             }
       
   228         case KStateParsingCredentials:
       
   229             {
       
   230             CSenCredential* pCredential = CSenCredential::NewL(
       
   231                 aNsUri, aLocalName, aQName, aAttributes, AsElement());
       
   232 
       
   233             CleanupStack::PushL(pCredential);  // bugfix 2004-08-09
       
   234 
       
   235             if (iNotOnOrAfter != Time::NullTTime())
       
   236                 {
       
   237                 pCredential->SetValidUntil(iNotOnOrAfter);
       
   238                 }
       
   239 
       
   240             delete ipCredential;
       
   241             ipCredential = pCredential;
       
   242             CleanupStack::Pop(); // class owns the pCredential now..
       
   243             DelegateParsingL(*ipCredential);
       
   244             iState = KStateParsingSingleCredential;
       
   245             break;
       
   246             }
       
   247         default:
       
   248             {
       
   249             break;
       
   250             }
       
   251         }
       
   252     }
       
   253 
       
   254 void CIdWsfDsQueryResponse::EndElementL(
       
   255     const TDesC8& aNsUri,
       
   256     const TDesC8& aLocalName,
       
   257     const TDesC8& aQName)
       
   258     {
       
   259     switch(iState)
       
   260         {
       
   261         case KStateParsingResourceOffering:
       
   262             {
       
   263             if (aLocalName == KResourceOfferingName)
       
   264                 {
       
   265                 User::LeaveIfError(
       
   266                             iResourceOfferings.Append(ipResourceOffering));
       
   267                 ipResourceOffering = NULL;
       
   268                 iState = KStateIgnore;
       
   269                 }
       
   270             else if (aLocalName == KResourceIdName ||
       
   271                         aLocalName == KEncryptedResourceIdName)
       
   272                 {
       
   273                 ipResourceOffering->SetResourceIdL(Content());
       
   274                 }
       
   275 
       
   276             else if (aLocalName == KDescriptionElementLocalName)
       
   277                 {
       
   278                 ipResourceOffering->AddServiceInstanceL(ipServiceInstance);
       
   279 
       
   280                 // alloc new instance for the next parsing cycle
       
   281                 ipServiceInstance =
       
   282                         CIdWsfServiceInstance::NewL(*ipServiceInstance);
       
   283                 break;
       
   284                 }
       
   285             else
       
   286                 {
       
   287                 if (aLocalName == KProviderIdName)
       
   288                     {
       
   289                     ipServiceInstance->SetProviderIdL(Content());
       
   290                     break;
       
   291                     }
       
   292                 else if (aLocalName == KSecurityMechIdName)
       
   293                     {
       
   294                     ipServiceInstance->AddSecurityMechL(Content());
       
   295                     break;
       
   296                     }
       
   297                 else if (aLocalName == KCredentialRefName)
       
   298                     {
       
   299                     ipServiceInstance->AddCredentialRefL(Content());
       
   300                     break;
       
   301                     }
       
   302                 else if (aLocalName == KEndpointName)
       
   303                     {
       
   304                     ipServiceInstance->SetEndPointL(Content());
       
   305                     break;
       
   306                     }
       
   307                 else if (aLocalName == KServiceTypeName)
       
   308                     {
       
   309                     ipServiceInstance->SetServiceTypeL(Content());
       
   310                     break;
       
   311                     }
       
   312                 else if (aLocalName == KOptionName)
       
   313                     {
       
   314                     CSenFacet* pFacet = CSenFacet::NewL();
       
   315                     CleanupStack::PushL( pFacet );
       
   316                     pFacet->SetNameL(Content());
       
   317                     pFacet->SetTypeL(KDiscoOption);
       
   318                     ipResourceOffering->SetFacetL(*pFacet);
       
   319                     CleanupStack::PopAndDestroy( pFacet ); // SetFacetL does not take ownership but makes a copy of the facet insteadfs
       
   320                     break;
       
   321                     }
       
   322                 }
       
   323             break;
       
   324             }
       
   325         case KStateParsingEncryptedResourceId:
       
   326             {
       
   327             if (aLocalName == KResourceIdName ||
       
   328                 aLocalName == KEncryptedResourceIdName)
       
   329                 {
       
   330                 ipResourceOffering->SetResourceIdL(Content());
       
   331                 iState = KStateParsingResourceOffering;
       
   332                 }
       
   333             else WriteEndElementL(aNsUri, aLocalName, aQName);
       
   334             break;
       
   335             }
       
   336         case KStateParsingCredentials:
       
   337             {
       
   338             if (aLocalName == KCredentialsName)
       
   339                 {
       
   340                 iNotOnOrAfter = Time::NullTTime();
       
   341                 iState = KStateIgnore;
       
   342                 }
       
   343             break;
       
   344             }
       
   345         case KStateParsingSingleCredential:
       
   346             {
       
   347 
       
   348             HBufC8* pAsXml = ipCredential->AsXmlL();
       
   349             CleanupStack::PushL(pAsXml);
       
   350             const TDesC8& refId = ipCredential->Id();
       
   351 
       
   352             if(pAsXml && refId.Length()>0)
       
   353                 {
       
   354                 ipCredential->DetachL();
       
   355 
       
   356                 TInt count(iResourceOfferings.Count());
       
   357                 for (TInt i = 0; i < count; i++)
       
   358                     {
       
   359                     iResourceOfferings[i]->AddCredentialL(*ipCredential);
       
   360                     }
       
   361                 delete ipCredential;
       
   362                 }
       
   363             else
       
   364                 delete ipCredential; // ownership was _not_ transferred(!),
       
   365                                      // forced to delete here
       
   366 
       
   367             CleanupStack::PopAndDestroy(); // pAsXml;
       
   368 
       
   369             ipCredential = NULL;
       
   370             iState = KStateParsingCredentials;
       
   371             break;
       
   372             }
       
   373         default: // corresponds with ref-impl (Java) having case
       
   374                  // BaseFragment.IGNORE: break;
       
   375             {
       
   376             break;
       
   377             }
       
   378         }
       
   379     }
       
   380 
       
   381 TBool CIdWsfDsQueryResponse::IsOk()
       
   382     {
       
   383     if (!ipStatus)
       
   384         {
       
   385         return EFalse;
       
   386         }
       
   387     else
       
   388         {
       
   389         return (SenXmlUtils::EndsWith(*ipStatus, KOkLowerCase) ||
       
   390                 SenXmlUtils::EndsWith(*ipStatus, KOkUpperCase));
       
   391         }
       
   392     }
       
   393 
       
   394 // returns the first one (oldest) added..
       
   395 TPtrC8 CIdWsfDsQueryResponse::ResourceId()
       
   396     {
       
   397     if (iResourceOfferings.Count() > 0)
       
   398         {
       
   399         return iResourceOfferings[0]->ResourceId();
       
   400         }
       
   401     else
       
   402         {
       
   403         return NULL;
       
   404         }
       
   405     }
       
   406 
       
   407 RPointerArray<CIdWsfResourceOffering>&
       
   408                                     CIdWsfDsQueryResponse::ResourceOfferingsL()
       
   409     {
       
   410     return iResourceOfferings;
       
   411     }