connectivity/source/drivers/mozab/mozillasrc/MQueryHelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: MQueryHelper.cxx,v $
  10  * $Revision: 1.17 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_connectivity.hxx"
  33
  34 #include "MQueryHelper.hxx"
  35 #include "MTypeConverter.hxx"
  36 #include "MConnection.hxx"
  37 #include "MNSDeclares.hxx"
  38 #include "MLdapAttributeMap.hxx"
  39
  40 #include <connectivity/dbexception.hxx>
  41
  42 #include "resource/mozab_res.hrc"
  43
  44 using namespace connectivity::mozab;
  45
  46
  47 NS_IMPL_THREADSAFE_ISUPPORTS1(connectivity::mozab::MQueryHelper,nsIAbDirectoryQueryResultListener)
  48
  49 //
  50 // class MQueryHelperResultEntry
  51 //
  52
  53
  54 MQueryHelperResultEntry::MQueryHelperResultEntry()
  55 {
  56     m_Card = NULL;
  57     m_RowStates = 0;
  58 }
  59
  60 MQueryHelperResultEntry::~MQueryHelperResultEntry()
  61 {
  62     OSL_TRACE("IN MQueryHelperResultEntry::~MQueryHelperResultEntry()\n");
  63     OSL_TRACE("OUT MQueryHelperResultEntry::~MQueryHelperResultEntry()\n");
  64
  65 }
  66 void
  67 MQueryHelperResultEntry::setCard(nsIAbCard *card)
  68 {
  69     m_Card = card;
  70 }
  71 nsIAbCard *
  72 MQueryHelperResultEntry::getCard()
  73 {
  74     return m_Card;
  75 }
  76 void MQueryHelperResultEntry::insert( const rtl::OString &key, rtl::OUString &value )
  77 {
  78     m_Fields[ key ] = value;
  79 }
  80
  81 rtl::OUString MQueryHelperResultEntry::getValue( const rtl::OString &key ) const
  82 {
  83     FieldMap::const_iterator iter = m_Fields.find( key );
  84     if ( iter == m_Fields.end() )
  85     {
  86         return rtl::OUString();
  87     }
  88     else
  89     {
  90         return iter->second;
  91     }
  92 }
  93
  94 void MQueryHelperResultEntry::setValue( const rtl::OString &key, const rtl::OUString & rValue)
  95 {
  96     m_Fields[ key ] = rValue;
  97 }
  98 //
  99 // class MQueryHelper
 100 //
 101 MQueryHelper::MQueryHelper()
 102     :m_nIndex( 0 )
 103     ,m_bHasMore( sal_True )
 104     ,m_bAtEnd( sal_False )
 105     ,m_bErrorCondition( sal_False )
 106     ,m_bQueryComplete( sal_False )
 107     ,mRefCnt( 0 ) // NSISUPPORTS - Initialize RefCnt to 0
 108 {
 109     m_aResults.clear();
 110 #if OSL_DEBUG_LEVEL > 0
 111     m_oThreadID = osl_getThreadIdentifier(NULL);
 112 #endif
 113 }
 114
 115 MQueryHelper::~MQueryHelper()
 116 {
 117     OSL_TRACE("IN MQueryHelper::~MQueryHelper()\n");
 118     clear_results();
 119     OSL_TRACE("OUT MQueryHelper::~MQueryHelper()\n");
 120 }
 121
 122 void
 123 MQueryHelper::append(MQueryHelperResultEntry* resEnt )
 124 {
 125     if ( resEnt != NULL ) {
 126         m_aResults.push_back( resEnt );
 127         m_bAtEnd   = sal_False;
 128     }
 129 }
 130
 131 void
 132 MQueryHelper::clear_results()
 133 {
 134     resultsArray::iterator iter = m_aResults.begin();
 135     while ( iter != m_aResults.end() ) {
 136         delete (*iter);
 137         ++iter;
 138     }
 139     m_aResults.clear();
 140 }
 141
 142 void
 143 MQueryHelper::rewind()
 144 {
 145     m_nIndex = 0;
 146 }
 147
 148 void
 149 MQueryHelper::reset()
 150 {
 151     m_nIndex = 0;
 152     m_bHasMore = sal_True;
 153     m_bQueryComplete = sal_False;
 154     m_bAtEnd = sal_False;
 155     m_bErrorCondition = sal_False;
 156     clear_results();
 157 }
 158
 159 void
 160 MQueryHelper::clearResultOrComplete()
 161 {
 162     // Don't use a Mutex, it should be called by a method already holding it.
 163     OSL_TRACE("In/Out : clearResultOrComplete()");
 164     m_aCondition.reset();
 165 }
 166
 167 void
 168 MQueryHelper::notifyResultOrComplete()
 169 {
 170     OSL_TRACE("In/Out : notifyResultOrComplete()");
 171     m_aCondition.set();
 172 }
 173
 174 sal_Bool
 175 MQueryHelper::waitForResultOrComplete(  )
 176 {
 177     TimeValue               timeValue = { 1, 0 };  // 20 Seconds 0 NanoSecond timeout
 178     sal_Int32                           times=0;
 179     osl::Condition::Result  rv = ::osl::Condition::result_ok;
 180
 181     OSL_TRACE("In : waitForResultOrComplete()");
 182     // Can't hold mutex or condition would never get set...
 183     while( (m_aCondition.check() == sal_False || rv  == ::osl::Condition::result_error) && times < 20) {
 184         rv = m_aCondition.wait( &timeValue );
 185         times ++;
 186     }
 187     if (times >= 20 &&  rv == ::osl::Condition::result_timeout ) {
 188         OSL_TRACE("waitForResultOrComplete() : Timeout!");
 189         m_aError.setResId( STR_TIMEOUT_WAITING );
 190         return sal_False;
 191     }
 192
 193     if ( isError() ) {
 194         OSL_TRACE("waitForResultOrComplete() : Error returned!");
 195         m_aError.setResId( STR_ERR_EXECUTING_QUERY );
 196         return sal_False;
 197     }
 198     m_aError.reset();
 199     OSL_TRACE("  Out : waitForResultOrComplete()");
 200     return sal_True;
 201 }
 202
 203
 204 MQueryHelperResultEntry*
 205 MQueryHelper::next( )
 206 {
 207     MQueryHelperResultEntry* result;
 208     sal_Int32                     index;
 209
 210     m_aMutex.acquire();
 211     index = m_nIndex;
 212     m_aMutex.release();
 213
 214     result = getByIndex( m_nIndex + 1) ; // Add 1 as Row is numbered from 1 to N
 215
 216     if ( result ) {
 217         m_aMutex.acquire();
 218         m_nIndex++;
 219         m_aMutex.release();
 220     }
 221
 222     return( result );
 223 }
 224
 225 MQueryHelperResultEntry*
 226 MQueryHelper::getByIndex( sal_uInt32 nRow )
 227 {
 228     // Row numbers are from 1 to N, need to ensure this, and then
 229     // substract 1
 230     if ( nRow < 1 ) {
 231         return( NULL );
 232     }
 233
 234     do {
 235         // Obtain the Mutex - don't use a guard as we want to be able to release
 236         // and acquire again...
 237         m_aMutex.acquire();
 238         if ( nRow > m_aResults.size() )
 239         {
 240             if ( m_bQueryComplete )
 241             {
 242                 m_bAtEnd = sal_True;
 243                 m_aMutex.release();
 244                 return( NULL );
 245             }
 246             else
 247             {
 248                 clearResultOrComplete();
 249                 m_aMutex.release();
 250                 if ( !waitForResultOrComplete( ) )
 251                     return( NULL );
 252             }
 253         }
 254         else
 255         {
 256             m_aMutex.release();
 257             return( m_aResults[ nRow -1 ] );
 258         }
 259     } while ( sal_True );
 260 }
 261
 262 sal_Bool
 263 MQueryHelper::hasMore() const
 264 {
 265     return m_bHasMore;
 266 }
 267
 268 sal_Bool
 269 MQueryHelper::atEnd() const
 270 {
 271     return m_bAtEnd;
 272 }
 273
 274 sal_Bool
 275 MQueryHelper::isError() const
 276 {
 277     return m_bErrorCondition;
 278 }
 279
 280 sal_Bool
 281 MQueryHelper::queryComplete() const
 282 {
 283     return m_bQueryComplete;
 284 }
 285
 286 sal_Bool
 287 MQueryHelper::waitForQueryComplete(  )
 288 {
 289     m_aMutex.acquire();
 290
 291     OSL_TRACE("In : waitForQueryComplete()");
 292     if ( ! m_bQueryComplete ) {
 293         do
 294         {
 295             m_aMutex.release();
 296             clearResultOrComplete();
 297             if ( !waitForResultOrComplete( ) )
 298                 return( sal_False );
 299             m_aMutex.acquire();
 300         }
 301         while ( !m_bQueryComplete );
 302     }
 303
 304     m_aMutex.release();
 305     OSL_TRACE("Out : waitForQueryComplete()");
 306     return( sal_True );
 307 }
 308
 309 sal_Bool
 310 MQueryHelper::waitForRow( sal_Int32 rowNum )
 311 {
 312     m_aMutex.acquire();
 313     do
 314     {
 315         m_aMutex.release();
 316         clearResultOrComplete();
 317         if ( !waitForResultOrComplete() )
 318             return( sal_False );
 319         m_aMutex.acquire();
 320     }
 321     while ( !m_bQueryComplete && m_aResults.size() < (size_t)rowNum );
 322
 323     m_aMutex.release();
 324     return( sal_True );
 325 }
 326
 327 // -------------------------------------------------------------------------
 328
 329 sal_Int32
 330 MQueryHelper::getResultCount() const
 331 {
 332     OSL_TRACE( "IN MQueryHelper::getResultCount()" );
 333     if ( !m_bQueryComplete )
 334     {
 335         OSL_TRACE( "\tOUT MQueryHelper::getResultCount() = -1\n");
 336         return -1;
 337     }
 338     else
 339     {
 340         OSL_TRACE( "\tOUT MQueryHelper::getResultCount() = %d\n", m_aResults.size() );
 341         return static_cast<sal_Int32>(m_aResults.size());
 342     }
 343 }
 344
 345 // -------------------------------------------------------------------------
 346
 347 sal_uInt32
 348 MQueryHelper::getRealCount() const
 349 {
 350     OSL_TRACE( "IN/OUT MQueryHelper::getRealCount() = %d\n", m_aResults.size() );
 351     return static_cast<sal_Int32>(m_aResults.size());
 352 }
 353
 354 // -------------------------------------------------------------------------
 355 NS_IMETHODIMP MQueryHelper::OnQueryItem(nsIAbDirectoryQueryResult *result)
 356 {
 357     ::osl::MutexGuard aGuard( m_aMutex );
 358 #if OSL_DEBUG_LEVEL > 0
 359     OSL_TRACE( "IN MQueryHelper::OnQueryItem() Caller thread: %4d \n",m_oThreadID );
 360 #endif
 361     nsresult rv;
 362     PRInt32 resultType;
 363
 364     if ( result == NULL ) {
 365         OSL_TRACE("\tresult ptr is NULL\n");
 366         return NS_OK;
 367     }
 368
 369     // Get return status of executeQuery() call.
 370     rv = result -> GetType(&resultType);
 371     NS_ENSURE_SUCCESS(rv, rv);
 372
 373     // Check for errors of the executeQuery() call.
 374     switch ( resultType ) {
 375     case nsIAbDirectoryQueryResult::queryResultError:
 376         OSL_TRACE("\tresultType == nsIAbDirectoryQueryResult::queryResultError\n");
 377         m_bQueryComplete = sal_True;
 378         m_bErrorCondition = sal_True;
 379         notifyResultOrComplete();
 380         return NS_OK;
 381     case nsIAbDirectoryQueryResult::queryResultStopped:
 382         OSL_TRACE("\tresultType == nsIAbDirectoryQueryResult::queryResultStopped\n");
 383         m_bQueryComplete = sal_True;
 384         notifyResultOrComplete();
 385         return NS_OK;
 386     case nsIAbDirectoryQueryResult::queryResultComplete:
 387         OSL_TRACE("\tresultType == nsIAbDirectoryQueryResult::queryResultComplete\n");
 388         m_bQueryComplete = sal_True;
 389         notifyResultOrComplete();
 390         return NS_OK;
 391     case nsIAbDirectoryQueryResult::queryResultMatch:
 392         OSL_TRACE("IN MQueryHelper::OnQueryItem --> queryResultMatch\n");
 393         // Don't return, continues onto rest of method.
 394         break;
 395     default:
 396         OSL_TRACE("\t******** Unexpected : resultType\n");
 397         m_bQueryComplete = sal_True;
 398         return NS_OK;
 399     }
 400
 401     // Initialise an array that holds the resultset of the query.
 402     nsCOMPtr<nsISupportsArray> properties;
 403     rv = result -> GetResult(getter_AddRefs (properties));
 404     NS_ENSURE_SUCCESS(rv, rv);
 405
 406
 407     nsCOMPtr<nsISupports> item;
 408     rv = properties -> GetElementAt(0, getter_AddRefs(item));
 409     NS_ENSURE_SUCCESS(rv, rv);
 410
 411     nsCOMPtr<nsIAbDirectoryQueryPropertyValue> property(do_QueryInterface(item, &rv));
 412     NS_ENSURE_SUCCESS(rv, rv);
 413
 414     char *name;
 415     rv = property -> GetName(&name);
 416     NS_ENSURE_SUCCESS(rv, rv);
 417     if ( !strcmp(name,"card:nsIAbCard") )
 418     {
 419         nsCOMPtr<nsISupports> cardSupports;
 420         property->GetValueISupports (getter_AddRefs (cardSupports));
 421         nsCOMPtr<nsIAbCard> card(do_QueryInterface(cardSupports, &rv));
 422         NS_ENSURE_SUCCESS(rv, rv);
 423
 424         getCardValues(card);
 425     }
 426     nsMemory::Free(name);
 427
 428     OSL_TRACE( "\tOUT MQueryHelper::OnQueryItem()\n" );
 429
 430     notifyResultOrComplete();
 431
 432     return(NS_OK);
 433 }
 434
 435 // -----------------------------------------------------------------------------
 436 void MQueryHelper::notifyQueryError()
 437 {
 438     m_bQueryComplete = sal_True ;
 439     notifyResultOrComplete() ;
 440 }
 441
 442 const char * getAddrURI(const nsIAbDirectory*  directory)
 443 {
 444     nsresult retCode;
 445     nsCOMPtr<nsIRDFResource> rdfResource = do_QueryInterface((nsISupports *)directory, &retCode) ;
 446     if (NS_FAILED(retCode)) { return NULL; }
 447     const char * uri;
 448     retCode=rdfResource->GetValueConst(&uri);
 449     if (NS_FAILED(retCode)) { return NULL; }
 450     return uri;
 451  }
 452
 453 #define ENSURE_GETUPDATECARD(x) \
 454     if (NS_FAILED(retCode))     \
 455     {   \
 456         OSL_TRACE( x ); \
 457         return card;    \
 458     }
 459 static NS_DEFINE_CID(kRDFServiceCID, NS_RDFSERVICE_CID);
 460
 461 //Some address book does not support query uri on card
 462 //In this case, we can't resync the cards,  we just return the old cards
 463 nsIAbCard * getUpdatedCard( nsIAbCard*  card)
 464 {
 465     OSL_ENSURE(card != NULL, "getUpdatedCard for NULL");
 466     nsresult retCode;
 467     nsCOMPtr<nsIRDFResource> rdfResource = do_QueryInterface((nsISupports *)card, &retCode) ;
 468     ENSURE_GETUPDATECARD( "IN getUpdatedCard: Card does not support nsIRDFResource\n" );
 469
 470     const char * uri;
 471     retCode=rdfResource->GetValueConst(&uri);
 472     ENSURE_GETUPDATECARD( "IN getUpdatedCard: Card does not has a uri\n" );
 473
 474     nsCOMPtr<nsIRDFService> rdfService (do_GetService(kRDFServiceCID, &retCode)) ;
 475     ENSURE_GETUPDATECARD( "IN getUpdatedCard: Card does not has a uri\n" );
 476
 477     nsCOMPtr<nsIRDFResource> rdfCard;
 478
 479     retCode = rdfService->GetResource(nsDependentCString(uri), getter_AddRefs(rdfCard)) ;
 480     ENSURE_GETUPDATECARD( "IN getUpdatedCard: Can not get the updated card\n" );
 481
 482     nsCOMPtr<nsIAbCard> aNewCard=do_QueryInterface((nsISupports *)rdfCard, &retCode);
 483     ENSURE_GETUPDATECARD( "IN getUpdatedCard: Error in get new card\n" );
 484
 485     return aNewCard;
 486  }
 487
 488 #define ENSURE_MOZAB_PROFILE_NOT_LOOKED(directory)      \
 489     if (getDirectoryType(directory) == SDBCAddress::Mozilla && isProfileLocked(NULL))   \
 490     {   \
 491         m_aError.setResId( STR_MOZILLA_IS_RUNNIG_NO_CHANGES ); \
 492         return sal_False;       \
 493     }
 494
 495 sal_Int32 MQueryHelper::commitCard(const sal_Int32 rowIndex,nsIAbDirectory * directory)
 496 {
 497     ENSURE_MOZAB_PROFILE_NOT_LOOKED(directory);
 498
 499     MQueryHelperResultEntry *resEntry = getByIndex(rowIndex);
 500     if (!resEntry)
 501     {
 502         return sal_False;
 503     }
 504     nsIAbCard *card=resEntry->getCard();
 505     if (!card)
 506     {
 507         return sal_False;
 508     }
 509     nsresult rv;
 510     PRBool hasCard;
 511     rv = directory->HasCard(card,&hasCard);
 512     if (setCardValues(rowIndex) != sal_True)
 513         return sal_False;
 514
 515     if (!NS_FAILED(rv) && hasCard)
 516     {
 517                 rv = card->EditCardToDatabase(getAddrURI(directory));
 518     }
 519     else
 520     {
 521         nsIAbCard *addedCard=NULL;
 522         rv = directory->AddCard(card,&addedCard);
 523         if (!NS_FAILED(rv))
 524             resEntry->setCard(addedCard);
 525     }
 526     //We return NS_ERROR_FILE_ACCESS_DENIED in the case the mozillaAB has been changed out side of our process
 527     if (rv == NS_ERROR_FILE_ACCESS_DENIED )
 528         m_aError.setResId( STR_FOREIGN_PROCESS_CHANGED_AB );
 529
 530     return !(NS_FAILED(rv));
 531 }
 532
 533 sal_Int32 MQueryHelper::deleteCard(const sal_Int32 rowIndex,nsIAbDirectory * directory)
 534 {
 535     ENSURE_MOZAB_PROFILE_NOT_LOOKED(directory);
 536     MQueryHelperResultEntry *resEntry = getByIndex(rowIndex);
 537     if (!resEntry)
 538     {
 539         return sal_False;
 540     }
 541     nsIAbCard *card=resEntry->getCard();
 542     if (!card)
 543     {
 544         return sal_False;
 545     }
 546     nsresult rv;
 547     PRBool hasCard;
 548     if (resEntry->getRowStates() == RowStates_Inserted)
 549     {
 550         rv = 0;
 551         hasCard = sal_True;
 552     }
 553     else
 554         rv = directory->HasCard(card,&hasCard);
 555
 556     if (!NS_FAILED(rv) && hasCard)
 557     {
 558         nsCOMPtr <nsISupportsArray> cardsToDelete;
 559         rv = NS_NewISupportsArray(getter_AddRefs(cardsToDelete));
 560         if (NS_SUCCEEDED(rv))
 561         {
 562             nsCOMPtr<nsISupports> supports = do_QueryInterface(card, &rv);
 563             if (NS_SUCCEEDED(rv))
 564             {
 565                 rv = cardsToDelete->AppendElement(supports);
 566                 if (NS_SUCCEEDED(rv))
 567                     rv = directory->DeleteCards(cardsToDelete);
 568             }
 569         }
 570     }
 571
 572     if (NS_SUCCEEDED(rv))
 573         resEntry->setRowStates(RowStates_Deleted);
 574     //We return NS_ERROR_FILE_ACCESS_DENIED in the case the mozillaAB has been changed out side of our process
 575     if (rv == NS_ERROR_FILE_ACCESS_DENIED )
 576         m_aError.setResId( STR_FOREIGN_PROCESS_CHANGED_AB );
 577     return !(NS_FAILED(rv));
 578 }
 579
 580 sal_Bool MQueryHelper::setCardValues(const sal_Int32 rowIndex)
 581 {
 582     MQueryHelperResultEntry *resEntry = getByIndex(rowIndex);
 583     if (!resEntry)
 584     {
 585         m_aError.setResId( STR_CANT_FIND_ROW );
 586         return sal_False;
 587     }
 588     nsIAbCard *card=resEntry->getCard();
 589     if (!card)
 590     {
 591         m_aError.setResId( STR_CANT_FIND_CARD_FOR_ROW );
 592         return sal_False;
 593     }
 594
 595     MLdapAttributeMap::fillCardFromResult( *card, *resEntry );
 596     return sal_True;
 597 }
 598
 599 void MQueryHelper::getCardValues(nsIAbCard *card,sal_Int32 rowIndex)
 600 {
 601     MQueryHelperResultEntry *resEntry;
 602     if (rowIndex>0)
 603     {
 604         resEntry = getByIndex(rowIndex);
 605     }
 606     else
 607         resEntry = new MQueryHelperResultEntry();
 608
 609     MLdapAttributeMap::fillResultFromCard( *resEntry, *card );
 610     resEntry->setCard(card);
 611     if (!rowIndex)
 612         append( resEntry );
 613 }
 614 sal_Bool MQueryHelper::resyncRow(sal_Int32 rowIndex)
 615 {
 616
 617     MQueryHelperResultEntry *resEntry = getByIndex(rowIndex);
 618     if (!resEntry)
 619     {
 620         m_aError.setResId( STR_CANT_FIND_ROW );
 621         return sal_False;
 622     }
 623     nsIAbCard *card=resEntry->getCard();
 624     card = getUpdatedCard(card);
 625     getCardValues(card,rowIndex);
 626     return sal_True;
 627 }
 628 // -------------------------------------------------------------------------
 629 sal_Int32 MQueryHelper::createNewCard()
 630 {
 631     ::osl::MutexGuard aGuard( m_aMutex );
 632     nsresult rv;
 633     nsCOMPtr <nsIAbCard> card = do_CreateInstance(NS_ABCARDPROPERTY_CONTRACTID, &rv);
 634     //set default values
 635       getCardValues(card);
 636     return static_cast<sal_Int32>(m_aResults.size());
 637 }
 638