vcs.maemo.org Git - qtmeetings/blob - src/IO/Communication/MessagingUtils.cpp

   1 #include <QUrl>
   2
   3 #include "MessagingUtils.h"
   4 #include "Meeting.h"
   5 #include "Configuration.h"
   6
   7 /*
   8  * BaseMessage class functions
   9 */
  10 BaseMessage::BaseMessage()
  11 {
  12 #ifdef MU_DEBUG
  13         qDebug( "BaseMessage::BaseMessage" );
  14 #endif
  15         iMessage = new QDomDocument();
  16 #ifdef MU_DEBUG
  17         qDebug( "BaseMessage::BaseMessage end" );
  18 #endif
  19 }
  20
  21 BaseMessage::~BaseMessage()
  22 {
  23 #ifdef MU_DEBUG
  24         qDebug( "BaseMessage::~BaseMessage" );
  25 #endif
  26         if( iMessage )
  27                 {
  28                 delete iMessage;
  29                 iMessage = 0;
  30                 }
  31 #ifdef MU_DEBUG
  32         qDebug( "BaseMessage::~BaseMessage end" );
  33 #endif
  34 }
  35
  36 QList<QDomNode> BaseMessage::getNodesByName( const QString& aNodeName, const QString& aParentName, QDomNode* aRootNode )
  37 {
  38 #ifdef MU_DEBUG
  39         qDebug( "BaseMessage::getNodesByName" );
  40 #endif
  41
  42         //TODO: Add implementation for attribute search
  43
  44         QDomNodeList list;
  45         QList<QDomNode> specList;
  46
  47         list = ( aRootNode ) ? aRootNode->toElement().elementsByTagName( aNodeName ) : iMessage->elementsByTagName( aNodeName );
  48
  49         for( int i=0; i<list.count(); i++ )
  50         {
  51                 if( aParentName != QString::null )
  52                 {
  53                 if( !list.item( i ).parentNode().isNull() && list.item( i ).parentNode().isElement() && list.item( i ).parentNode().toElement().tagName().compare( aParentName ) == 0 )
  54                         specList.append( list.item( i ) );
  55                 }
  56                 else
  57                         specList.append( list.item( i ) );
  58         }
  59 #ifdef MU_DEBUG
  60         qDebug( "BaseMessage::getNodesByName end" );
  61 #endif
  62         return specList;
  63 }
  64
  65 QDomNode BaseMessage::getNodeFromDocument( const QString& aNodeName,
  66                                                                 QDomNode::NodeType aNodeType,
  67                                                                 const QString& aParentName,
  68                                                                 int aIndex,
  69                                                                 QDomNode* aRootNode )
  70 {
  71 #ifdef MU_DEBUG
  72         qDebug( "BaseMessage::getNodeFromDocument" );
  73 #endif
  74         QDomNode node;
  75         if( aNodeType == QDomNode::ElementNode )
  76                 node = getElementFromDocument( aNodeName, aParentName, aIndex, aRootNode );
  77         else if( aNodeType == QDomNode::AttributeNode )
  78                 node = getAttributeFromDocument( aNodeName, aParentName, aIndex, aRootNode );
  79 #ifdef MU_DEBUG
  80         qDebug( "BaseMessage::getNodeFromDocument end" );
  81 #endif
  82         return node;
  83 }
  84
  85 QDomNode BaseMessage::getAttributeFromDocument( const QString& aAttributeName,
  86                                                                 const QString& aParentName,
  87                                                                 int aIndex,
  88                                                                 QDomNode* aRootNode )
  89 {
  90 #ifdef MU_DEBUG
  91         qDebug( "BaseMessage::getAttributeFromDocument" );
  92 #endif
  93
  94         QDomNode root;
  95         QDomNode node;
  96         QDomNode parent;
  97
  98         root = ( !aRootNode ) ? iMessage->documentElement() : *aRootNode;
  99         if( root.isNull() )
 100                 {
 101 #ifdef MU_DEBUG
 102         qDebug( "BaseMessage::getAttributeFromDocument : RootNode is NULL." );
 103 #endif
 104                 return node;
 105                 }
 106
 107         if( aParentName != QString::null )
 108         {
 109                 if( root.isElement() )
 110                 {
 111                         QDomNodeList list = root.toElement().elementsByTagName( aParentName );
 112                         if( list.count() > 0 ) parent = list.item( 0 );
 113                 }
 114         }
 115
 116         QDomNamedNodeMap attrs = parent.attributes();
 117
 118         int count = attrs.count();
 119         if( count==0 || aIndex >= count || !attrs.contains( aAttributeName ) ) return root;
 120
 121         QList<QDomAttr> list;
 122
 123         for( int i=0; i<count; i++ )
 124         {
 125                 QDomAttr attr = attrs.item( i ).toAttr();
 126
 127                 if( attr.name().compare( aAttributeName ) == 0 || attr.localName().compare( aAttributeName ) == 0 )
 128                 {
 129                         if( aParentName != QString::null && ( attr.ownerElement().tagName().compare( aParentName ) == 0 || attr.ownerElement().localName().compare( aParentName ) == 0 ))
 130                         {
 131                                 list.append( attr );
 132                         }
 133                         else
 134                                 list.append( attr );
 135                 }
 136
 137         }
 138
 139         if( list.count() > 0 )
 140                 node = list.at( aIndex );
 141
 142 #ifdef MU_DEBUG
 143         qDebug( "BaseMessage::getAttributeFromDocument end." );
 144 #endif
 145
 146         return node;
 147 }
 148
 149 QDomNode BaseMessage::getElementFromDocument( const QString& aElementName,
 150                                                                 const QString& aParentName,
 151                                                                 int aIndex,
 152                                                                 QDomNode* aRootNode )
 153 {
 154 #ifdef MU_DEBUG
 155         qDebug( "BaseMessage::getElementFromDocument" );
 156 #endif
 157                 QDomNode node;
 158                 QDomNodeList elems;
 159
 160                 if( !aRootNode )
 161                 {
 162                 elems = iMessage->elementsByTagName( aElementName );
 163                 }
 164                 else
 165                 {
 166                 elems = aRootNode->toElement().elementsByTagName( aElementName );
 167                 }
 168
 169                 int count = elems.count();
 170                 if( count == 0 || aIndex >= count )
 171                 {
 172 #ifdef MU_DEBUG
 173         qDebug( "BaseMessage::getElementFromDocument : No Elements found." );
 174 #endif
 175                         return node; //no elements found
 176                 }
 177
 178                 QList<QDomElement> list;
 179
 180                 for( int i=0; i<count; i++ )
 181                 {
 182                         QDomElement elem = elems.item( i ).toElement();
 183                         if( elem.tagName().compare( aElementName ) == 0 || elem.localName().compare( aElementName ) == 0 )
 184                         {
 185                                 if( aParentName != QString::null )
 186                                 {
 187                                         if( !elem.parentNode().isNull() )
 188                                         {
 189                                                 if( elem.parentNode().toElement().tagName().compare( aParentName ) == 0 || elem.parentNode().toElement().tagName().compare( aParentName ) == 0 )
 190                                                         list.append( elem );
 191                                         }
 192                                 }
 193                                 else
 194                                         list.append( elem );
 195                         }
 196
 197                 }
 198
 199                 if( list.count() > 0 )
 200                         node = list.at( aIndex );
 201
 202 #ifdef MU_DEBUG
 203         qDebug( "BaseMessage::getElementFromDocument end" );
 204 #endif
 205                 return node;
 206 }
 207
 208 bool BaseMessage::matchName( const QDomNode& aNode, const QString& aName )
 209 {
 210 #ifdef MU_DEBUG
 211         qDebug( "BaseMessage::matchName" );
 212 #endif
 213         if( aNode.isElement() )
 214         {
 215                 if( aNode.toElement().tagName().toLower().compare( aName.toLower() ) == 0
 216                                 || aNode.localName().toLower().compare( aName.toLower() ) == 0 )
 217                 {
 218 #ifdef MU_DEBUG
 219         qDebug( "BaseMessage::matchName end" );
 220 #endif
 221                         return true;
 222                 }
 223         }
 224         else if( aNode.isAttr() )
 225         {
 226                 if( aNode.toAttr().name().toLower().compare( aName.toLower() ) == 0
 227                                 || aNode.localName().toLower().compare( aName.toLower() ) == 0 )
 228                 {
 229 #ifdef MU_DEBUG
 230         qDebug( "BaseMessage::matchName end" );
 231 #endif
 232                         return true;
 233                 }
 234         }
 235 #ifdef MU_DEBUG
 236         qDebug( "BaseMessage::matchName : No match." );
 237 #endif
 238         return false;
 239 }
 240
 241 QByteArray BaseMessage::getMessage()
 242 {
 243 #ifdef MU_DEBUG
 244         qDebug( "BaseMessage::getMessage" );
 245 #endif
 246         QByteArray msg;
 247         if( iMessage )
 248         {
 249                 msg.append( iMessage->toByteArray() );
 250         }
 251 #ifdef MU_DEBUG
 252         qDebug( "BaseMessage::getMessage end" );
 253 #endif
 254         return msg;
 255 }
 256
 257 /*
 258  * RequestMessage class functions
 259 */
 260 RequestMessage::RequestMessage( RequestCommandId aCommandId ) : iCurrCmd( aCommandId )
 261 {
 262 #ifdef MU_DEBUG
 263         qDebug( "RequestMessage::RequestMessage" );
 264 #endif
 265         createEnvelopeBase();
 266
 267         if( aCommandId != ReqCmdNoCommand )
 268         {
 269                 createMessageStructure( aCommandId );
 270         }
 271 #ifdef MU_DEBUG
 272         qDebug( "RequestMessage::RequestMessage end" );
 273 #endif
 274 }
 275
 276 RequestMessage::RequestMessage( const QString& /*aFileName*/ )
 277 {
 278         //createEnvelopeBase();
 279         //TODO: read operation structures from a file
 280 }
 281
 282 int RequestMessage::addNode( const QDomNode& aNode, QDomNode::NodeType aNodeType, const QString& aParentName, int aIndex, QDomNode* aRootNode )
 283 {
 284 #ifdef MU_DEBUG
 285         qDebug( "RequestMessage::addNode" );
 286 #endif
 287
 288         if( !iMessage )
 289         {
 290 #ifdef MU_DEBUG
 291         qDebug( "RequestMessage::addNode : iMessage is NULL." );
 292 #endif
 293                 return MsgErrSomeError;
 294         }
 295
 296         int err = MsgErrNoError;
 297
 298         if( aNodeType == QDomNode::ElementNode && aNode.isElement() )
 299         {
 300                 if( aParentName == QString::null )
 301                 {
 302                         if( !aRootNode )
 303                         iMessage->appendChild( aNode );
 304                         else
 305                         aRootNode->appendChild( aNode );
 306                 }
 307                 else
 308                 {
 309                         QDomNodeList list = ( aRootNode ) ? aRootNode->toElement().elementsByTagName( aParentName ) : iMessage->elementsByTagName( aParentName );
 310
 311                         if( list.count() == 0 || aIndex >= list.count() ) err = MsgErrSomeError;
 312                         else
 313                         {
 314                                 QDomElement node = list.at( aIndex ).toElement();
 315                                 node.appendChild( aNode );
 316                         }
 317                 }
 318         }
 319         else if( aNodeType == QDomNode::AttributeNode && aNode.isAttr() )
 320         {
 321                 if( aParentName != QString::null )
 322                 {
 323                         QDomNodeList list = ( aRootNode ) ? aRootNode->toElement().elementsByTagName( aParentName ) : iMessage->elementsByTagName( aParentName );
 324
 325                         if( list.count() == 0 || aIndex >= list.count() ) err = MsgErrSomeError;
 326                         else
 327                         {
 328                                 QDomElement node = list.at( aIndex ).toElement();
 329                                 node.setAttributeNode( aNode.toAttr() );
 330                         }
 331                 }
 332                 else
 333                         err = MsgErrSomeError; //Attribute must have a parent specified
 334         }
 335         else
 336                 err = MsgErrSomeError;
 337
 338 #ifdef MU_DEBUG
 339         qDebug( "RequestMessage::addNode end : err=%d", err );
 340 #endif
 341         return err;
 342 }
 343
 344 int RequestMessage::setNodeValue( const QString& aNodeName, const QString& aValue, QDomNode::NodeType aNodeType, const QString& aParentName, int aIndex, QDomNode* aRootNode )
 345 {
 346 #ifdef MU_DEBUG
 347         qDebug( "RequestMessage::setNodeValue" );
 348 #endif
 349
 350         QDomNode node = getNodeFromDocument( aNodeName, aNodeType, aParentName, aIndex, aRootNode );
 351         if( node.isNull() || !iMessage )
 352                 {
 353 #ifdef MU_DEBUG
 354         qDebug( "RequestMessage::setNodeValue : Node is NULL or iMessage is NULL." );
 355 #endif
 356                 return MsgErrSomeError;
 357                 }
 358
 359         int err = MsgErrNoError;
 360
 361         if( node.isElement() )
 362         {
 363                 node.appendChild( iMessage->createTextNode( aValue ) );
 364         }
 365         else if( node.isAttr() )
 366                 node.toAttr().setValue( aValue );
 367         else
 368                 err = MsgErrSomeError;
 369
 370 #ifdef MU_DEBUG
 371         qDebug( "RequestMessage::setNodeValue end : err=%d", err );
 372 #endif
 373         return err;
 374 }
 375
 376 int RequestMessage::createEnvelopeBase()
 377 {
 378 #ifdef MU_DEBUG
 379         qDebug( "RequestMessage::createEnvelopeBase" );
 380 #endif
 381         if( iMessage )
 382                 {
 383                 delete iMessage;
 384                 iMessage = 0;
 385                 }
 386
 387         iMessage = new QDomDocument();
 388
 389         int size = sizeof( reqCmdArrayEnvelopeBase ) / sizeof( MessageBodyElement );
 390         int err = MsgErrNoError;
 391
 392         QDomNode base = constructArrayToNode( reqCmdArrayEnvelopeBase, size );
 393
 394         if( !base.isNull() )
 395                 err = addNode( base );
 396         else err = MsgErrSomeError;
 397
 398 #ifdef MU_DEBUG
 399         qDebug( "RequestMessage::createEnvelopeBase end : err=%d", err );
 400 #endif
 401         return err;
 402 }
 403
 404 QString RequestMessage::getContentTypeForHeader( RequestCommandId aCommandId )
 405 {
 406 #ifdef MU_DEBUG
 407         qDebug( "RequestMessage::getContentTypeForHeader" );
 408 #endif
 409         QString contentType( QString::null );
 410
 411         RequestCommandId cmd = ( aCommandId == ReqCmdNoCommand ) ? iCurrCmd : aCommandId;
 412
 413         if( cmd != ReqCmdNoCommand )
 414         {
 415                 QString operation( QString::null );
 416                 switch( cmd )
 417                 {
 418                 //Used commands
 419                 case ReqCmdGetUserAvailability : { operation = "GetUserAvailability"; } break;
 420                 case ReqCmdConvertId : { operation = "ConvertId"; } break;
 421                 case ReqCmdGetItem : { operation = "GetItem"; } break;
 422
 423                 //Currently unused operations
 424
 425                 /*case ReqCmdAddDelegate : { operation = "AddDelegate"; } break;
 426                 case ReqCmdCopyFolder : { operation = "CopyFolder"; } break;
 427                 case ReqCmdCopyItem : { operation = "CopyItem"; } break;
 428                 case ReqCmdCreateAttachment : { operation = "CreateAttachment"; } break;
 429                 case ReqCmdCreateFolder : { operation = "CreateFolder"; } break;
 430                 case ReqCmdCreateItem : { operation = "CreateItem"; } break;
 431                 case ReqCmdCreateManagedFolder : { operation = "CreateManagedFolder"; } break;
 432                 case ReqCmdDeleteAttachment : { operation = "DeleteAttachment"; } break;
 433                 case ReqCmdDeleteFolder : { operation = "DeleteFolder"; } break;
 434                 case ReqCmdDeleteItem : { operation = "DeleteItem"; } break;
 435                 case ReqCmdExpandDL : { operation = "ExpandDL"; } break;
 436                 case ReqCmdFindFolder : { operation = "FindFolder"; } break;
 437                 case ReqCmdFindItem : { operation = "FindItem"; } break;
 438                 case ReqCmdGetAttachment : { operation = "GetAttachment"; } break;
 439                 case ReqCmdGetDelegate : { operation = "GetDelegate"; } break;
 440                 case ReqCmdGetEvents : { operation = "GetEvents"; } break;
 441                 case ReqCmdGetFolder : { operation = "GetFolder"; } break;
 442                 case ReqCmdGetUserOofSettings : { operation = "GetUserOofSettings"; } break;
 443                 case ReqCmdMoveFolder : { operation = "MoveFolder"; } break;
 444                 case ReqCmdMoveItem : { operation = "MoveItem"; } break;
 445                 case ReqCmdRemoveDelegate : { operation = "RemoveDelegate"; } break;
 446                 case ReqCmdResolveNames : { operation = "ResolveNames"; } break;
 447                 case ReqCmdSendItem : { operation = "SendItem"; } break;
 448                 case ReqCmdSetUserOofSettings : { operation = "SetUserOofSettings"; } break;
 449                 case ReqCmdSubscribe : { operation = "Subscribe"; } break;
 450                 case ReqCmdSyncFolderHierarchy : { operation = "SyncFolderHierarchy"; } break;
 451                 case ReqCmdSyncFolderItems : { operation = "SyncFolderItems"; } break;
 452                 case ReqCmdUnsubscribe : { operation = "Unsubscribe"; } break;
 453                 case ReqCmdUpdateDelegate : { operation = "UpdateDelegate"; } break;
 454                 case ReqCmdUpdateFolder : { operation = "UpdateFolder"; } break;
 455                 case ReqCmdUpdateItem : { operation = "UpdateItem"; } break;*/
 456                 default: break;
 457                 };
 458
 459                 if( operation != QString::null )
 460                 {
 461                         QString content( "text/xml; " );
 462                         QString charset( "utf-8; " );
 463                         contentType = QString( content + "charset=" + charset + "action=\"" + ACTION_URL + operation + "\"" );
 464                 }
 465         }
 466 #ifdef MU_DEBUG
 467         qDebug( "RequestMessage::getContentTypeForHeader end : contentType=%s", contentType.toStdString().data() );
 468 #endif
 469         return contentType;
 470 }
 471
 472 int RequestMessage::createMessageStructure()
 473 {
 474         return createMessageStructure( iCurrCmd );
 475 }
 476
 477 int RequestMessage::createMessageStructure( RequestCommandId aCommandId )
 478 {
 479 #ifdef MU_DEBUG
 480         qDebug( "RequestMessage::createMessageStructure" );
 481 #endif
 482         if( !iMessage )
 483         {
 484 #ifdef MU_DEBUG
 485         qDebug( "RequestMessage::createMessageStructure : iMessage is NULL" );
 486 #endif
 487                 return MsgErrSomeError;
 488         }
 489
 490         //Should always be soap:Envelope or first element in envelopebase array
 491         QDomNode last = iMessage->documentElement();
 492
 493         if( !matchName( last, reqCmdArrayEnvelopeBase[0].iElementName ) )
 494         {
 495 #ifdef MU_DEBUG
 496         qDebug( "RequestMessage::createMessageStructure : Document element is not valid SOAP envelope" );
 497 #endif
 498                 return MsgErrSomeError;
 499         }
 500
 501         QDomNode cmd;
 502         int err = MsgErrNoError;
 503
 504         switch( aCommandId )
 505         {
 506         case ReqCmdGetUserAvailability : { cmd = constructArrayToNode( reqCmdArrayGetUserAvailability, sizeof( reqCmdArrayGetUserAvailability ) / sizeof( MessageBodyElement ) ); } break;
 507         case ReqCmdConvertId : { cmd = constructArrayToNode( reqCmdArrayConvertId, sizeof( reqCmdArrayConvertId ) / sizeof( MessageBodyElement ) ); } break;
 508         case ReqCmdGetItem : { cmd = constructArrayToNode( reqCmdArrayGetCalendarItem, sizeof( reqCmdArrayGetCalendarItem ) / sizeof( MessageBodyElement ) ); } break;
 509         default: break;
 510         };
 511
 512         if( cmd.isNull() ) err = MsgErrSomeError;
 513         else{
 514                 err = addNode( cmd, QDomNode::ElementNode, reqCmdArrayEnvelopeBase[0].iElementName );
 515         }
 516 #ifdef MU_DEBUG
 517         qDebug( "RequestMessage::createMessageStructure end : err=%d", err );
 518 #endif
 519         return err;
 520 }
 521
 522 QDomNode RequestMessage::constructArrayToNode( const MessageBodyElement* aArray, int aSize )
 523 {
 524 #ifdef MU_DEBUG
 525         qDebug( "RequestMessage::constructArrayToNode" );
 526 #endif
 527         QDomElement target; //final node to be returned
 528
 529         if( !iMessage || aSize == 0 )
 530                 {
 531 #ifdef MU_DEBUG
 532         qDebug( "RequestMessage::constructArrayToNode : iMessage is NULL or aSize is 0." );
 533 #endif
 534                 return target;
 535                 }
 536
 537         QDomElement last; // last appended node
 538
 539         int currentLvl = 0; //current traversal level
 540         int idx = 0;
 541
 542         //get the root
 543         MessageBodyElement root = aArray[idx];
 544         if( root.iNodeType != QDomNode::ElementNode || root.iTraversalLevel > 0 )
 545         {
 546 #ifdef MU_DEBUG
 547         qDebug( "RequestMessage::constructArrayToNode : Malformed message definition. Check array for faults." );
 548 #endif
 549                 return target; //Root must be an element and on level 0
 550         }
 551         else
 552         {
 553                 if( root.iNamespace != QString::null )
 554                 {
 555                         //QString prefix = root.iNamespace
 556                         target = iMessage->createElementNS( root.iNamespace, root.iElementName );
 557                 }
 558                 else
 559                 {
 560                         target = iMessage->createElement( root.iElementName );
 561                 }
 562                 last = target;
 563                 idx++;
 564         }
 565
 566         for( int i=idx; i<aSize; i++ )
 567         {
 568                 MessageBodyElement element = aArray[i];
 569
 570                 if( element.iNodeType == QDomNode::ElementNode )
 571                 {
 572                         //Node is an element node
 573                         QDomElement elem;
 574                         if( element.iNamespace != QString::null )
 575                         {
 576                                 elem = iMessage->createElementNS( element.iNamespace, element.iElementName );
 577                         }
 578                         else
 579                         {
 580                                 elem = iMessage->createElement( element.iElementName );
 581                         }
 582                         if( element.iTraversalLevel == currentLvl )
 583                         {
 584                                 if( currentLvl == 0 )
 585                                 {
 586 #ifdef MU_DEBUG
 587         qDebug( "RequestMessage::constructArrayToNode : Malformed message definition. Check array for faults." );
 588 #endif
 589                                         return target; //Only root can be at traversal level 0
 590                                 }
 591                                 else
 592                                 {
 593                                         //Sibling to previous
 594                                         if( !last.parentNode().isNull() )
 595                                                 last.parentNode().appendChild( elem );
 596                                         else
 597                                                 {
 598 #ifdef MU_DEBUG
 599         qDebug( "RequestMessage::constructArrayToNode : Malformed message definition. Check array for faults." );
 600 #endif
 601                                                 return target; //malformed. if last has no parent, it's a rootnode
 602                                                 }
 603                                 }
 604                         }
 605                         else if( element.iTraversalLevel > currentLvl )
 606                         {
 607                                 //check if node is child to previous
 608                                 //else there is something wrong in array representing the structure
 609                                 if( element.iTraversalLevel == currentLvl+1 )
 610                                 {
 611                                         last.appendChild( elem );
 612                                 }
 613                                 else
 614                                 {
 615 #ifdef MU_DEBUG
 616         qDebug( "RequestMessage::constructArrayToNode : Malformed message definition. Check array for faults." );
 617 #endif
 618                                         return target;
 619                                 }
 620                         }
 621                         else if( element.iTraversalLevel < currentLvl )
 622                         {
 623
 624                                 //Node is on more shallow level than previous
 625                                 //let's get it's parent
 626                                 int diff = currentLvl - element.iTraversalLevel;
 627
 628                                 for( int j=0; j<diff; j++ )
 629                                 {
 630                                         QDomNode temp = last.parentNode();
 631                                         last = temp.toElement();
 632                                 }
 633                                 last.parentNode().appendChild( elem );
 634                         }
 635                         else
 636                         {
 637 #ifdef MU_DEBUG
 638         qDebug( "RequestMessage::constructArrayToNode : Malformed message definition. Check array for faults." );
 639 #endif
 640                                 //some undefined error
 641                                 return target;
 642                         }
 643
 644                         last = elem;
 645                 }
 646                 else if( element.iNodeType == QDomNode::AttributeNode )
 647                 {
 648                         //Node is an attribute node
 649
 650                         QDomAttr attr;
 651                         if( element.iNamespace != QString::null )
 652                                  attr = iMessage->createAttributeNS( element.iNamespace, element.iElementName );
 653                         else
 654                                  attr = iMessage->createAttribute( element.iElementName );
 655
 656                         if( element.iTraversalLevel == currentLvl )
 657                         {
 658                                 last.setAttributeNode( attr );
 659                         }
 660                         else
 661                         {
 662 #ifdef MU_DEBUG
 663         qDebug( "RequestMessage::constructArrayToNode : Malformed message definition. Check array for faults." );
 664 #endif
 665                                 //error in template array.
 666                                 //attributes for element must be specified right after element
 667                                 //and must have same traversalId
 668                                 return target;
 669                         }
 670                 }
 671                 else
 672                 {
 673 #ifdef MU_DEBUG
 674         qDebug( "RequestMessage::constructArrayToNode : Node type not supported." );
 675 #endif
 676                         //node type not supported
 677                         return target;
 678                 }
 679
 680                 currentLvl = element.iTraversalLevel;
 681         }
 682 #ifdef MU_DEBUG
 683         qDebug( "RequestMessage::constructArrayToNode : end" );
 684 #endif
 685         return target;
 686 }
 687
 688 /*
 689  * ResponseMessage class functions
 690  */
 691 ResponseMessage::ResponseMessage()
 692 {
 693 #ifdef MU_DEBUG
 694         qDebug( "ResponseMessage::ResponseMessage" );
 695 #endif
 696         iMessage = new QDomDocument();
 697 #ifdef MU_DEBUG
 698         qDebug( "ResponseMessage::ResponseMessage end" );
 699 #endif
 700 }
 701
 702 ResponseMessage::ResponseMessage( const QByteArray& aData )
 703 {
 704 #ifdef MU_DEBUG
 705         qDebug( "ResponseMessage::ResponseMessage" );
 706 #endif
 707         iMessage->setContent( aData, true );
 708 #ifdef MU_DEBUG
 709         qDebug( "ResponseMessage::ResponseMessage end" );
 710 #endif
 711 }
 712
 713 QString ResponseMessage::getNodeValue( const QString& aNodeName, QDomNode::NodeType aNodeType, const QString& aParentName, int aIndex, QDomNode* aRootNode )
 714 {
 715 #ifdef MU_DEBUG
 716         qDebug( "ResponseMessage::getNodeValue" );
 717 #endif
 718         QString value = QString::null;
 719         QDomNode node = getNodeFromDocument( aNodeName, aNodeType, aParentName, aIndex, aRootNode );
 720         if( !node.isNull() )
 721         {
 722                 if( node.isElement() )
 723                         value = node.toElement().text();
 724                 else if( node.isAttr() )
 725                         value = node.toAttr().value();
 726         }
 727 #ifdef MU_DEBUG
 728         qDebug( "ResponseMessage::getNodeValue end" );
 729 #endif
 730         return value;
 731 }
 732
 733 bool ResponseMessage::hasErrors()
 734 {
 735 #ifdef MU_DEBUG
 736         qDebug( "ResponseMessage::hasErrors" );
 737 #endif
 738         if( !iMessage )
 739                 {
 740 #ifdef MU_DEBUG
 741         qDebug( "ResponseMessage::hasErrors : iMessage is NULL." );
 742 #endif
 743                 return true;
 744                 }
 745
 746         QDomElement root = iMessage->documentElement();
 747         bool err = false;
 748
 749         QString rootname = ( root.prefix() == QString::null ) ? root.tagName() : root.localName();
 750         err = ( rootname.compare( QString( "Envelope" ) ) == 0 ) ? false : true;
 751
 752         QDomNodeList list = iMessage->elementsByTagName( QString( "m:ResponseCode" ) );
 753         for( int i=0; i<list.count(); i++ )
 754         {
 755                 if( list.item(i).nodeValue().compare( "NoError" ) != 0 )
 756                         {
 757                         err = true;
 758                         }
 759         }
 760 #ifdef MU_DEBUG
 761         qDebug( "ResponseMessage::hasErrors end : err=%d", err );
 762 #endif
 763         return err;
 764 }
 765
 766 /*
 767  * ReqMsgGetUserAvailability class functions
 768  */
 769
 770 ReqMsgGetUserAvailability::ReqMsgGetUserAvailability() : RequestMessage( ReqCmdGetUserAvailability )
 771 {
 772 #ifdef MU_DEBUG
 773         qDebug( "ReqMsgGetUserAvailability::ReqMsgGetUserAvailability" );
 774 #endif
 775         if( iMessage && iCurrCmd == ReqCmdGetUserAvailability )
 776         {
 777                 setNodeValue( QString( "MergedFreeBusyIntervalInMinutes" ), QString::number( 60 ) );
 778                 setNodeValue( QString( "RequestedView" ), QString( "DetailedMerged" ) );
 779         }
 780 #ifdef MU_DEBUG
 781         qDebug( "ReqMsgGetUserAvailability::ReqMsgGetUserAvailability end" );
 782 #endif
 783 }
 784
 785 int ReqMsgGetUserAvailability::addUser( const QString& aAddress, const QString& /*aAttendeeType*/, const QString& aExcludeConflicts )
 786 {
 787 #ifdef MU_DEBUG
 788         qDebug( "ReqMsgGetUserAvailability::addUser" );
 789 #endif
 790         if( !iMessage || iCurrCmd != ReqCmdGetUserAvailability )
 791         {
 792 #ifdef MU_DEBUG
 793         qDebug( "ReqMsgGetUserAvailability::addUser : iMessage is NULL or current command id is wrong" );
 794 #endif
 795                 return MsgErrSomeError;
 796         }
 797
 798         int err = MsgErrNoError;
 799         int size = sizeof( reqCmdMailboxElement ) / sizeof( MessageBodyElement );
 800
 801         //Create mailbox data element
 802         QDomNode mailbox = constructArrayToNode( reqCmdMailboxElement, size );
 803         if( !mailbox.isNull() )
 804         {
 805                 QDomNode email;
 806
 807                 if( mailbox.hasChildNodes() )
 808                 {
 809                         for ( QDomNode subnode = mailbox.firstChild(); !subnode.isNull(); subnode = subnode.nextSibling() )
 810                         {
 811                                 qDebug( "subnode: %s", subnode.toElement().tagName().toStdString().data() );
 812                                 if( matchName( subnode, QString( "Email" ) ) )
 813                                         {
 814                                         email = subnode;
 815                                         }
 816                         }
 817                 }
 818
 819                 setNodeValue( QString( "Address" ), aAddress, QDomNode::ElementNode, QString( "Email" ), 0, &email );
 820                 setNodeValue( QString( "AttendeeType" ), QString( "Required" ), QDomNode::ElementNode, QString( "MailboxData" ), 0, &mailbox );
 821                 setNodeValue( QString( "ExcludeConflicts" ), aExcludeConflicts, QDomNode::ElementNode, QString( "MailboxData" ), 0, &mailbox );
 822
 823                 err = addNode( mailbox, QDomNode::ElementNode, QString( "MailboxDataArray" ) );
 824         }
 825         else
 826                 err = MsgErrSomeError;
 827
 828 #ifdef MU_DEBUG
 829         qDebug( "ReqMsgGetUserAvailability::addUser end : err=%d", err );
 830 #endif
 831         return err;
 832 }
 833
 834 int ReqMsgGetUserAvailability::setTimeWindow( const QDateTime& aStart, const QDateTime& aEnd )
 835 {
 836 #ifdef MU_DEBUG
 837         qDebug( "ReqMsgGetUserAvailability::setTimeWindow" );
 838 #endif
 839         if( !iMessage || iCurrCmd != ReqCmdGetUserAvailability )
 840         {
 841 #ifdef MU_DEBUG
 842         qDebug( "ReqMsgGetUserAvailability::setTimeWindow : iMessage is NULL or command id is wrong" );
 843 #endif
 844                 return MsgErrSomeError;
 845         }
 846
 847         int err = MsgErrNoError;
 848
 849         err = setNodeValue( QString( "StartTime" ), aStart.toString( Qt::ISODate ) );
 850         err = setNodeValue( QString( "EndTime" ), aEnd.toString( Qt::ISODate ) );
 851
 852 #ifdef MU_DEBUG
 853         qDebug( "ReqMsgGetUserAvailability::setTimeWindow end : err=%d", err );
 854 #endif
 855         return err;
 856 }
 857
 858 int ReqMsgGetUserAvailability::setTimeZone()
 859 {
 860 #ifdef MU_DEBUG
 861         qDebug( "ReqMsgGetUserAvailability::setTimeZone" );
 862 #endif
 863         if( !iMessage || iCurrCmd != ReqCmdGetUserAvailability )
 864         {
 865 #ifdef MU_DEBUG
 866         qDebug( "ReqMsgGetUserAvailability::setTimeZone : iMessage is NULL or command id is wrong" );
 867 #endif
 868                 return MsgErrSomeError;
 869         }
 870         int err = MsgErrNoError;
 871         //TODO: timezone and daylight times to application configuration
 872         setNodeValue( QString( "Bias" ), QString::number( -120 ), QDomNode::ElementNode, QString( "TimeZone" ) );
 873         setNodeValue( QString( "Bias" ), QString::number( 0 ), QDomNode::ElementNode, QString( "StandardTime" ) );
 874         setNodeValue( QString( "Time" ), QString( "03:00:00" ), QDomNode::ElementNode, QString( "StandardTime" ) );
 875         setNodeValue( QString( "DayOrder" ), QString::number( 5 ), QDomNode::ElementNode, QString( "StandardTime" ) );
 876         setNodeValue( QString( "Month" ), QString::number( 10 ), QDomNode::ElementNode, QString( "StandardTime" ) );
 877         setNodeValue( QString( "DayOfWeek" ), QString( "Sunday" ), QDomNode::ElementNode, QString( "StandardTime" ) );
 878         setNodeValue( QString( "Bias" ), QString::number( -60 ), QDomNode::ElementNode, QString( "DaylightTime" ) );
 879         setNodeValue( QString( "Time" ), QString( "03:00:00" ), QDomNode::ElementNode, QString( "DaylightTime" ) );
 880         setNodeValue( QString( "DayOrder" ), QString::number( 1 ), QDomNode::ElementNode, QString( "DaylightTime" ) );
 881         setNodeValue( QString( "Month" ), QString::number( 4 ), QDomNode::ElementNode, QString( "DaylightTime" ) );
 882         setNodeValue( QString( "DayOfWeek" ), QString( "Sunday" ), QDomNode::ElementNode, QString( "DaylightTime" ) );
 883
 884 #ifdef MU_DEBUG
 885         qDebug( "ReqMsgGetUserAvailability::setTimeZone end : err=%d", err );
 886 #endif
 887         return err;
 888 }
 889
 890 /*
 891  * ReqMsgConvertMeetingId class functions
 892  */
 893 ReqMsgConvertMeetingId::ReqMsgConvertMeetingId( const QString& aItemId, const QString& aMailbox )
 894 {
 895 #ifdef MU_DEBUG
 896         qDebug( "ReqMsgConvertMeetingId::ReqMsgConvertMeetingId" );
 897 #endif
 898         //For this class, we're not going to provide id for base class as parameter,
 899         //because before content structure initialization, we must add SOAP header to envelope
 900         iCurrCmd = ReqCmdConvertId;
 901
 902         QDomNode header = constructArrayToNode( reqCmdArrayConvertIdHeader, sizeof( reqCmdArrayConvertIdHeader ) / sizeof( MessageBodyElement ) );
 903
 904         if( !header.isNull() )
 905         {
 906                 int err = addNode( header, QDomNode::ElementNode, reqCmdArrayEnvelopeBase[0].iElementName );
 907
 908                 if( err == MsgErrNoError )
 909                 {
 910                 createMessageStructure( ReqCmdConvertId );
 911
 912                 if( aItemId != QString::null ) setItemId( aItemId );
 913                 if( aMailbox != QString::null ) setMailbox( aMailbox );
 914
 915                 setNodeValue( QString( "Version" ), QString( "Exchange2007_SP1" ), QDomNode::AttributeNode, QString( "RequestServerVersion" ) );
 916                 setNodeValue( QString( "DestinationFormat" ), QString( "EwsLegacyId" ), QDomNode::AttributeNode, QString( "ConvertId" ) );
 917                 setNodeValue( QString( "Format" ), QString( "HexEntryId" ), QDomNode::AttributeNode, QString( "AlternateId" ) );
 918                 }
 919         }
 920         //setNodeValue( QString( "xmlns:t" ), NS_T, QDomNode::AttributeNode, QString( "ConvertId" ) );
 921
 922         //Must be added (for now at least) like this, because Envelope is initialized already, without attributes
 923         /*QDomAttr attr = iMessage->createAttribute( QString( "xmlns:t" ) );
 924         attr.setValue( NS_T );
 925         addNode( attr, QDomNode::AttributeNode, QString( "Envelope" ) );
 926         */
 927 #ifdef MU_DEBUG
 928         qDebug( "ReqMsgConvertMeetingId::ReqMsgConvertMeetingId end" );
 929 #endif
 930 }
 931
 932 int ReqMsgConvertMeetingId::setItemId( const QString& aItemId )
 933 {
 934 #ifdef MU_DEBUG
 935         qDebug( "ReqMsgConvertMeetingId::setItemId" );
 936 #endif
 937         int err = setNodeValue( QString( "Id" ), aItemId, QDomNode::AttributeNode, QString( "AlternateId" ) );
 938 #ifdef MU_DEBUG
 939         qDebug( "ReqMsgConvertMeetingId::setItemId end : err=%d", err );
 940 #endif
 941         return err;
 942 }
 943
 944 int ReqMsgConvertMeetingId::setMailbox( const QString& aMailbox )
 945 {
 946 #ifdef MU_DEBUG
 947         qDebug( "ReqMsgConvertMeetingId::setMailbox" );
 948 #endif
 949         int err = setNodeValue( QString( "Mailbox" ), aMailbox, QDomNode::AttributeNode, QString( "AlternateId" ) );
 950 #ifdef MU_DEBUG
 951         qDebug( "ReqMsgConvertMeetingId::setMailbox end : err=%d", err );
 952 #endif
 953         return err;
 954 }
 955
 956 /*
 957  * ReqMsgGetCalendarItem class functions
 958  */
 959 ReqMsgGetCalendarItem::ReqMsgGetCalendarItem( const QString& aItemId ) : RequestMessage( ReqCmdGetItem )
 960 {
 961 #ifdef MU_DEBUG
 962         qDebug( "ReqMsgGetCalendarItem::ReqMsgGetCalendarItem" );
 963 #endif
 964         if( iMessage && iCurrCmd == ReqCmdGetItem )
 965         {
 966                 setNodeValue( QString( "BaseShape" ), QString( "AllProperties" ) );
 967
 968                 if( aItemId != QString::null )
 969                         setItemId( aItemId );
 970         }
 971 #ifdef MU_DEBUG
 972         qDebug( "ReqMsgGetCalendarItem::ReqMsgGetCalendarItem end" );
 973 #endif
 974 }
 975
 976 int ReqMsgGetCalendarItem::setItemId( const QString& aItemId )
 977 {
 978 #ifdef MU_DEBUG
 979         qDebug( "ReqMsgGetCalendarItem::setItemId" );
 980 #endif
 981         int err = setNodeValue( QString( "Id" ), aItemId, QDomNode::AttributeNode, QString( "ItemId" ), 0 );
 982 #ifdef MU_DEBUG
 983         qDebug( "ReqMsgGetCalendarItem::setItemId end : err=%d", err );
 984 #endif
 985         return err;
 986 }
 987
 988 /*
 989  * ResMsgGetUserAvailability class functions
 990  */
 991 ResMsgGetUserAvailability::ResMsgGetUserAvailability( const QByteArray& aData ) : ResponseMessage( aData )
 992 {
 993 #ifdef MU_DEBUG
 994         qDebug( "ResMsgGetUserAvailability::ResMsgGetUserAvailability" );
 995         qDebug( "ResMsgGetUserAvailability::ResMsgGetUserAvailability end" );
 996 #endif
 997 }
 998
 999 int ResMsgGetUserAvailability::getMeetingsFromResponse( QList<Meeting*>& aMeetings, const Room &aRoom )
1000 {
1001 #ifdef MU_DEBUG
1002         qDebug( "ResMsgGetUserAvailability::getMeetingsFromResponse" );
1003 #endif
1004                 if( !iMessage )
1005                         {
1006 #ifdef MU_DEBUG
1007         qDebug( "ResMsgGetUserAvailability::getMeetingsFromResponse : iMessage is NULL" );
1008 #endif
1009                         return MsgErrSomeError;
1010                         }
1011
1012                 //TODO: Clean this function a bit (see getMeetingDetailsFromResponse)
1013
1014                 int err = MsgErrNoError;
1015
1016                 QDomNodeList list = iMessage->elementsByTagName( QString( "CalendarEvent" ) );
1017
1018                 for( int i=0; i<list.count(); i++ )
1019                 {
1020                         QDomElement e = list.item( i ).toElement();
1021                         QString tagName = ( e.prefix() == QString::null ) ? e.tagName().toLower() : e.localName().toLower();
1022
1023                         if( !e.isNull() && tagName == "calendarevent" )
1024                         {
1025
1026                                 QString id, startsAt, endsAt, organizer, subject;
1027
1028                                 for ( QDomNode subnode = e.firstChild(); !subnode.isNull(); subnode = subnode.nextSibling() )
1029                                 {
1030                                         QDomElement e = subnode.toElement();
1031                                         QString tagName = ( e.prefix() == QString::null ) ? e.tagName().toLower() : e.localName().toLower();
1032
1033                                         if( tagName == QString( "starttime" ) )
1034                                         {
1035                                                 startsAt = e.text();
1036                                         }
1037                                         else if( tagName == QString( "endtime" ) )
1038                                         {
1039                                                 endsAt = e.text();
1040                                         }
1041                                         else if( tagName == QString( "calendareventdetails" ) )
1042                                         {
1043
1044                                                 for ( QDomNode detailnode = subnode.firstChild(); !detailnode.isNull(); detailnode = detailnode.nextSibling() )
1045                                                 {
1046
1047                                                         QDomElement e = detailnode.toElement();
1048                                                         QString tagName = ( e.prefix() == QString::null ) ? e.tagName().toLower() : e.localName().toLower();
1049
1050                                                         if( tagName == QString( "id" ) )
1051                                                         {
1052                                                                 id = e.text();
1053                                                         }
1054
1055                                                         if( tagName == QString( "subject" ) )
1056                                                         {
1057                                                                 subject = e.text();
1058                                                         }
1059                                                 }
1060                                         }
1061                                 }
1062
1063                                 QDateTime start = QDateTime::fromString( startsAt, Qt::ISODate );
1064                                 QDateTime end = QDateTime::fromString( endsAt, Qt::ISODate );
1065
1066                                 aMeetings.append( new Meeting(
1067                                                 id,
1068                                                 aRoom,
1069                                                 start,
1070                                                 end,
1071                                                 subject ) );
1072
1073                         }
1074                 }
1075 #ifdef MU_DEBUG
1076         qDebug( "ResMsgGetUserAvailability::getMeetingsFromResponse end : err=%d", err );
1077 #endif
1078                 return err;
1079 }
1080
1081 /*
1082  * ResMsgGetCalendarItem class functions
1083  */
1084 int ResMsgGetCalendarItem::getMeetingDetailsFromResponse( Meeting& aMeeting )
1085 {
1086 #ifdef MU_DEBUG
1087         qDebug( "ResMsgGetCalendarItem::getMeetingDetailsFromResponse" );
1088 #endif
1089         if( !iMessage || hasErrors() )
1090                 {
1091 #ifdef MU_DEBUG
1092         qDebug( "ResMsgGetCalendarItem::getMeetingDetailsFromResponse : iMessage is NULL or response has errors." );
1093 #endif
1094                 return MsgErrSomeError;
1095                 }
1096
1097         QString name, address, description; //Organizer
1098
1099         QDomNode box = getElementFromDocument( QString( "Mailbox" ), QString( "Organizer" ), 0 );
1100
1101         if( !box.isNull() && box.hasChildNodes() )
1102         {
1103                 for ( QDomNode subnode = box.firstChild(); !subnode.isNull(); subnode = subnode.nextSibling() )
1104                 {
1105                         if( matchName( subnode, QString( "Name" ) ) )
1106                                 name = subnode.toElement().text();
1107                         else if( matchName( subnode, QString( "EmailAddress" ) ) )
1108                                 address = subnode.toElement().text();
1109                 }
1110         }
1111
1112         QDomNode body = getElementFromDocument( QString( "Body" ), QString( "CalendarItem" ), 0 );
1113
1114         if( body.isElement() )
1115                 description = body.toElement().text();
1116
1117         aMeeting.setOrganizer( name, address );
1118         aMeeting.setDescription( description );
1119
1120 #ifdef MU_DEBUG
1121         qDebug( "ResMsgGetCalendarItem::getMeetingDetailsFromResponse end" );
1122 #endif
1123         return MsgErrNoError;
1124 }
1125