ucb/source/ucp/webdav/webdavdatasupplier.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <osl/diagnose.h>
  21 #include <com/sun/star/ucb/OpenMode.hpp>
  22 #include <ucbhelper/contentidentifier.hxx>
  23 #include <ucbhelper/providerhelper.hxx>
  24 #include "webdavdatasupplier.hxx"
  25 #include "webdavcontent.hxx"
  26 #include "ContentProperties.hxx"
  27 #include "DAVSession.hxx"
  28 #include "SerfUri.hxx"
  29
  30 using namespace com::sun::star;
  31 using namespace http_dav_ucp;
  32
  33 namespace http_dav_ucp
  34 {
  35
  36
  37
  38 // struct ResultListEntry.
  39
  40
  41
  42 struct ResultListEntry
  43 {
  44     OUString                             aId;
  45     uno::Reference< ucb::XContentIdentifier > xId;
  46     uno::Reference< ucb::XContent >           xContent;
  47     uno::Reference< sdbc::XRow >              xRow;
  48     const ContentProperties*                  pData;
  49
  50     ResultListEntry( const ContentProperties* pEntry ) : pData( pEntry ) {};
  51     ~ResultListEntry() { delete pData; }
  52 };
  53
  54
  55
  56 // ResultList.
  57
  58
  59
  60 typedef std::vector< ResultListEntry* > ResultList;
  61
  62
  63
  64 // struct DataSupplier_Impl.
  65
  66
  67
  68 struct DataSupplier_Impl
  69 {
  70     osl::Mutex                                   m_aMutex;
  71     ResultList                                   m_aResults;
  72     rtl::Reference< Content >                    m_xContent;
  73     uno::Reference< uno::XComponentContext > m_xContext;
  74     sal_Int32                                    m_nOpenMode;
  75     bool                                     m_bCountFinal;
  76     bool                                     m_bThrowException;
  77
  78     DataSupplier_Impl(
  79                 const uno::Reference< uno::XComponentContext >& rxContext,
  80                 const rtl::Reference< Content >& rContent,
  81                 sal_Int32 nOpenMode )
  82     : m_xContent( rContent ), m_xContext( rxContext ), m_nOpenMode( nOpenMode ),
  83       m_bCountFinal( false ), m_bThrowException( false ) {}
  84     ~DataSupplier_Impl();
  85 };
  86
  87
  88 DataSupplier_Impl::~DataSupplier_Impl()
  89 {
  90     ResultList::const_iterator it  = m_aResults.begin();
  91     ResultList::const_iterator end = m_aResults.end();
  92
  93     while ( it != end )
  94     {
  95         delete (*it);
  96         ++it;
  97     }
  98 }
  99
 100 }
 101
 102
 103
 104
 105 // DataSupplier Implementation.
 106
 107
 108
 109
 110 DataSupplier::DataSupplier(
 111             const uno::Reference< uno::XComponentContext >& rxContext,
 112             const rtl::Reference< Content >& rContent,
 113             sal_Int32 nOpenMode )
 114 : m_pImpl( new DataSupplier_Impl( rxContext, rContent, nOpenMode ) )
 115 {
 116 }
 117
 118
 119 // virtual
 120 DataSupplier::~DataSupplier()
 121 {
 122     delete m_pImpl;
 123 }
 124
 125
 126 // virtual
 127 OUString DataSupplier::queryContentIdentifierString( sal_uInt32 nIndex )
 128 {
 129     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 130
 131     if ( nIndex < m_pImpl->m_aResults.size() )
 132     {
 133         OUString aId = m_pImpl->m_aResults[ nIndex ]->aId;
 134         if ( aId.getLength() )
 135         {
 136             // Already cached.
 137             return aId;
 138         }
 139     }
 140
 141     if ( getResult( nIndex ) )
 142     {
 143         OUString aId = m_pImpl->m_xContent->getResourceAccess().getURL();
 144
 145         const ContentProperties& props
 146                             = *( m_pImpl->m_aResults[ nIndex ]->pData );
 147
 148         if ( ( aId.lastIndexOf( '/' ) + 1 ) != aId.getLength() )
 149             aId += "/";
 150
 151         aId += props.getEscapedTitle();
 152
 153         if ( props.isTrailingSlash() )
 154             aId += "/";
 155
 156         m_pImpl->m_aResults[ nIndex ]->aId = aId;
 157         return aId;
 158     }
 159     return OUString();
 160 }
 161
 162
 163 // virtual
 164 uno::Reference< ucb::XContentIdentifier >
 165 DataSupplier::queryContentIdentifier( sal_uInt32 nIndex )
 166 {
 167     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 168
 169     if ( nIndex < m_pImpl->m_aResults.size() )
 170     {
 171         uno::Reference< ucb::XContentIdentifier > xId
 172             = m_pImpl->m_aResults[ nIndex ]->xId;
 173         if ( xId.is() )
 174         {
 175             // Already cached.
 176             return xId;
 177         }
 178     }
 179
 180     OUString aId = queryContentIdentifierString( nIndex );
 181     if ( aId.getLength() )
 182     {
 183         uno::Reference< ucb::XContentIdentifier > xId
 184             = new ::ucbhelper::ContentIdentifier( aId );
 185         m_pImpl->m_aResults[ nIndex ]->xId = xId;
 186         return xId;
 187     }
 188     return uno::Reference< ucb::XContentIdentifier >();
 189 }
 190
 191
 192 // virtual
 193 uno::Reference< ucb::XContent >
 194 DataSupplier::queryContent( sal_uInt32 nIndex )
 195 {
 196     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 197
 198     if ( nIndex < m_pImpl->m_aResults.size() )
 199     {
 200         uno::Reference< ucb::XContent > xContent
 201             = m_pImpl->m_aResults[ nIndex ]->xContent;
 202         if ( xContent.is() )
 203         {
 204             // Already cached.
 205             return xContent;
 206         }
 207     }
 208
 209     uno::Reference< ucb::XContentIdentifier > xId
 210         = queryContentIdentifier( nIndex );
 211     if ( xId.is() )
 212     {
 213         try
 214         {
 215             uno::Reference< ucb::XContent > xContent
 216                 = m_pImpl->m_xContent->getProvider()->queryContent( xId );
 217             m_pImpl->m_aResults[ nIndex ]->xContent = xContent;
 218             return xContent;
 219
 220         }
 221         catch ( ucb::IllegalIdentifierException& )
 222         {
 223         }
 224     }
 225     return uno::Reference< ucb::XContent >();
 226 }
 227
 228
 229 // virtual
 230 bool DataSupplier::getResult( sal_uInt32 nIndex )
 231 {
 232     osl::ClearableGuard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 233
 234     if ( m_pImpl->m_aResults.size() > nIndex )
 235     {
 236         // Result already present.
 237         return true;
 238     }
 239
 240     // Obtain values...
 241     if ( getData() )
 242     {
 243         if ( m_pImpl->m_aResults.size() > nIndex )
 244         {
 245             // Result already present.
 246             return true;
 247         }
 248     }
 249
 250     return false;
 251 }
 252
 253
 254 // virtual
 255 sal_uInt32 DataSupplier::totalCount()
 256 {
 257   // Obtain values...
 258   getData();
 259
 260   return m_pImpl->m_aResults.size();
 261 }
 262
 263
 264 // virtual
 265 sal_uInt32 DataSupplier::currentCount()
 266 {
 267     return m_pImpl->m_aResults.size();
 268 }
 269
 270
 271 // virtual
 272 bool DataSupplier::isCountFinal()
 273 {
 274     return m_pImpl->m_bCountFinal;
 275 }
 276
 277
 278 // virtual
 279 uno::Reference< sdbc::XRow > DataSupplier::queryPropertyValues(
 280                                                     sal_uInt32 nIndex  )
 281 {
 282     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 283
 284     if ( nIndex < m_pImpl->m_aResults.size() )
 285     {
 286         uno::Reference< sdbc::XRow > xRow = m_pImpl->m_aResults[ nIndex ]->xRow;
 287         if ( xRow.is() )
 288         {
 289             // Already cached.
 290             return xRow;
 291         }
 292     }
 293
 294     if ( getResult( nIndex ) )
 295     {
 296         uno::Reference< sdbc::XRow > xRow
 297             = Content::getPropertyValues(
 298                 m_pImpl->m_xContext,
 299                 getResultSet()->getProperties(),
 300                 *(m_pImpl->m_aResults[ nIndex ]->pData),
 301                 rtl::Reference< ::ucbhelper::ContentProviderImplHelper >(
 302                     m_pImpl->m_xContent->getProvider().get() ),
 303                 queryContentIdentifierString( nIndex ) );
 304         m_pImpl->m_aResults[ nIndex ]->xRow = xRow;
 305         return xRow;
 306     }
 307
 308     return uno::Reference< sdbc::XRow >();
 309 }
 310
 311
 312 // virtual
 313 void DataSupplier::releasePropertyValues( sal_uInt32 nIndex )
 314 {
 315     osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 316
 317     if ( nIndex < m_pImpl->m_aResults.size() )
 318         m_pImpl->m_aResults[ nIndex ]->xRow = uno::Reference< sdbc::XRow >();
 319 }
 320
 321
 322 // virtual
 323 void DataSupplier::close()
 324 {
 325 }
 326
 327
 328 // virtual
 329 void DataSupplier::validate()
 330     throw( ucb::ResultSetException )
 331 {
 332     if ( m_pImpl->m_bThrowException )
 333         throw ucb::ResultSetException();
 334 }
 335
 336 bool DataSupplier::getData()
 337 {
 338     osl::ClearableGuard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 339
 340     if ( !m_pImpl->m_bCountFinal )
 341     {
 342         std::vector< OUString > propertyNames;
 343         ContentProperties::UCBNamesToDAVNames(
 344                         getResultSet()->getProperties(), propertyNames );
 345
 346         // Append "resourcetype", if not already present. It's value is
 347         // needed to get a valid ContentProperties::pIsFolder value, which
 348         // is needed for OpenMode handling.
 349
 350         std::vector< OUString >::const_iterator it
 351             = propertyNames.begin();
 352         std::vector< OUString >::const_iterator end
 353             = propertyNames.end();
 354
 355         while ( it != end )
 356         {
 357             if ( (*it).equals( DAVProperties::RESOURCETYPE ) )
 358                 break;
 359
 360             ++it;
 361         }
 362
 363         if ( it == end )
 364             propertyNames.push_back( DAVProperties::RESOURCETYPE );
 365
 366         std::vector< DAVResource > resources;
 367         try
 368         {
 369             // propfind depth 1, get property values for parent AND for each
 370             // child
 371             m_pImpl->m_xContent->getResourceAccess()
 372                 .PROPFIND( DAVONE,
 373                            propertyNames,
 374                            resources,
 375                            getResultSet()->getEnvironment() );
 376         }
 377         catch ( DAVException & )
 378         {
 379             SAL_WARN( "ucb.ucp.webdav", "PROPFIND : DAVException" );
 380             m_pImpl->m_bThrowException = true;
 381         }
 382
 383         if ( !m_pImpl->m_bThrowException )
 384         {
 385             try
 386             {
 387                 SerfUri aURI(
 388                     m_pImpl->m_xContent->getResourceAccess().getURL() );
 389                 OUString aPath = aURI.GetPath();
 390
 391                 if ( aPath.endsWith("/") )
 392                     aPath = aPath.copy( 0, aPath.getLength() - 1 );
 393
 394                 aPath = SerfUri::unescape( aPath );
 395                 bool bFoundParent = false;
 396
 397                 for ( sal_uInt32 n = 0; n < resources.size(); ++n )
 398                 {
 399                     const DAVResource & rRes = resources[ n ];
 400
 401                     // Filter parent, which is contained somewhere(!) in
 402                     // the vector.
 403                     if ( !bFoundParent )
 404                     {
 405                         try
 406                         {
 407                             SerfUri aCurrURI( rRes.uri );
 408                             OUString aCurrPath = aCurrURI.GetPath();
 409                             if ( aCurrPath.endsWith("/") )
 410                                 aCurrPath
 411                                     = aCurrPath.copy(
 412                                         0,
 413                                         aCurrPath.getLength() - 1 );
 414
 415                             aCurrPath = SerfUri::unescape( aCurrPath );
 416                             if ( aPath == aCurrPath )
 417                             {
 418                                 bFoundParent = true;
 419                                 continue;
 420                             }
 421                         }
 422                         catch ( DAVException const & )
 423                         {
 424                             // do nothing, ignore error. continue.
 425                         }
 426                     }
 427
 428                     ContentProperties* pContentProperties
 429                         = new ContentProperties( rRes );
 430
 431                     // Check resource against open mode.
 432                     switch ( m_pImpl->m_nOpenMode )
 433                     {
 434                     case ucb::OpenMode::FOLDERS:
 435                         {
 436                             bool bFolder = false;
 437
 438                             const uno::Any & rValue
 439                                 = pContentProperties->getValue(
 440                                     OUString(
 441                                             "IsFolder" ) );
 442                             rValue >>= bFolder;
 443
 444                             if ( !bFolder )
 445                                 continue;
 446
 447                             break;
 448                         }
 449
 450                     case ucb::OpenMode::DOCUMENTS:
 451                         {
 452                             bool bDocument = false;
 453
 454                             const uno::Any & rValue
 455                                 = pContentProperties->getValue(
 456                                     OUString(
 457                                             "IsDocument" ) );
 458                             rValue >>= bDocument;
 459
 460                             if ( !bDocument )
 461                                 continue;
 462
 463                             break;
 464                         }
 465
 466                     case ucb::OpenMode::ALL:
 467                     default:
 468                         break;
 469                     }
 470
 471                     m_pImpl->m_aResults.push_back(
 472                         new ResultListEntry( pContentProperties ) );
 473                 }
 474             }
 475             catch ( DAVException const & )
 476             {
 477             }
 478         }
 479
 480         m_pImpl->m_bCountFinal = true;
 481
 482         // Callback possible, because listeners may be informed!
 483         aGuard.clear();
 484         getResultSet()->rowCountFinal();
 485     }
 486     return !m_pImpl->m_bThrowException;
 487 }
 488
 489 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */