ucb/source/ucp/webdav/ContentProperties.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/util/DateTime.hpp>
  22 #include "SerfUri.hxx"
  23 #include "DAVResource.hxx"
  24 #include "DAVProperties.hxx"
  25 #include "DateTimeHelper.hxx"
  26 #include "webdavprovider.hxx"
  27 #include "ContentProperties.hxx"
  28
  29 using namespace com::sun::star;
  30 using namespace http_dav_ucp;
  31
  32 /*
  33 =============================================================================
  34
  35                             Property Mapping
  36
  37 =============================================================================
  38 HTTP (entity header)    WebDAV (property)   UCB (property)
  39 =============================================================================
  40
  41 Allow
  42 Content-Encoding
  43 Content-Language        getcontentlanguage
  44 Content-Length          getcontentlength    Size
  45 Content-Location
  46 Content-MD5
  47 Content-Range
  48 Content-Type            getcontenttype      MediaType
  49 Expires
  50 Last-Modified           getlastmodified     DateModified
  51                         creationdate        DateCreated
  52                         resourcetype        IsFolder,IsDocument,ContentType
  53                         displayname
  54 ETag (actually          getetag
  55 a response header )
  56                         lockdiscovery
  57                         supportedlock
  58                         source
  59                                             Title (always taken from URI)
  60
  61 =============================================================================
  62
  63 Important: HTTP headers will not be mapped to DAV properties; only to UCB
  64            properties. (Content-Length,Content-Type,Last-Modified)
  65 */
  66
  67
  68
  69
  70 // ContentProperties Implementation.
  71
  72
  73
  74
  75 // static member!
  76 uno::Any ContentProperties::m_aEmptyAny;
  77
  78 ContentProperties::ContentProperties( const DAVResource& rResource )
  79 : m_xProps( new PropertyValueMap ),
  80   m_bTrailingSlash( false )
  81 {
  82     SAL_WARN_IF( !rResource.uri.getLength(), "ucb.ucp.webdav",
  83                 "ContentProperties ctor - Empty resource URI!" );
  84
  85     // Title
  86     try
  87     {
  88         SerfUri aURI( rResource.uri );
  89         m_aEscapedTitle = aURI.GetPathBaseName();
  90
  91         (*m_xProps)[ OUString( "Title" ) ]
  92             = PropertyValue(
  93                 uno::makeAny( aURI.GetPathBaseNameUnescaped() ), true );
  94     }
  95     catch ( DAVException const & )
  96     {
  97         (*m_xProps)[ OUString( "Title" ) ]
  98             = PropertyValue(
  99                 uno::makeAny(
 100                     OUString( "*** unknown ***" ) ),
 101                 true );
 102     }
 103
 104     std::vector< DAVPropertyValue >::const_iterator it
 105         = rResource.properties.begin();
 106     std::vector< DAVPropertyValue >::const_iterator end
 107         = rResource.properties.end();
 108
 109     while ( it != end )
 110     {
 111         addProperty( (*it) );
 112         ++it;
 113     }
 114
 115     if ( rResource.uri.endsWith("/") )
 116         m_bTrailingSlash = true;
 117 }
 118
 119
 120 ContentProperties::ContentProperties(
 121                         const OUString & rTitle, bool bFolder )
 122 : m_xProps( new PropertyValueMap ),
 123   m_bTrailingSlash( false )
 124 {
 125     (*m_xProps)[ OUString( "Title" ) ]
 126         = PropertyValue( uno::makeAny( rTitle ), true );
 127     (*m_xProps)[ OUString( "IsFolder" ) ]
 128         = PropertyValue( uno::makeAny( bFolder ), true );
 129     (*m_xProps)[ OUString( "IsDocument" ) ]
 130         = PropertyValue( uno::makeAny( bool( !bFolder ) ), true );
 131 }
 132
 133
 134 ContentProperties::ContentProperties( const OUString & rTitle )
 135 : m_xProps( new PropertyValueMap ),
 136   m_bTrailingSlash( false )
 137 {
 138     (*m_xProps)[ OUString( "Title" ) ]
 139         = PropertyValue( uno::makeAny( rTitle ), true );
 140 }
 141
 142
 143 ContentProperties::ContentProperties()
 144 : m_xProps( new PropertyValueMap ),
 145   m_bTrailingSlash( false )
 146 {
 147 }
 148
 149
 150 ContentProperties::ContentProperties( const ContentProperties & rOther )
 151 : m_aEscapedTitle( rOther.m_aEscapedTitle ),
 152   m_xProps( rOther.m_xProps.get()
 153             ? new PropertyValueMap( *rOther.m_xProps )
 154             : new PropertyValueMap ),
 155   m_bTrailingSlash( rOther.m_bTrailingSlash )
 156 {
 157 }
 158
 159
 160 bool ContentProperties::contains( const OUString & rName ) const
 161 {
 162     if ( get( rName ) )
 163         return true;
 164     else
 165         return false;
 166 }
 167
 168
 169 const uno::Any & ContentProperties::getValue(
 170                                     const OUString & rName ) const
 171 {
 172     const PropertyValue * pProp = get( rName );
 173     if ( pProp )
 174         return pProp->value();
 175     else
 176         return m_aEmptyAny;
 177 }
 178
 179
 180 const PropertyValue * ContentProperties::get(
 181                                     const OUString & rName ) const
 182 {
 183     PropertyValueMap::const_iterator it = m_xProps->find( rName );
 184     const PropertyValueMap::const_iterator end = m_xProps->end();
 185
 186     if ( it == end )
 187     {
 188         it  = m_xProps->begin();
 189         while ( it != end )
 190         {
 191             if ( (*it).first.equalsIgnoreAsciiCase( rName ) )
 192                 return &(*it).second;
 193
 194             ++it;
 195         }
 196         return 0;
 197     }
 198     else
 199         return &(*it).second;
 200 }
 201
 202
 203 // static
 204 void ContentProperties::UCBNamesToDAVNames(
 205                             const uno::Sequence< beans::Property > & rProps,
 206                             std::vector< OUString > & propertyNames,
 207                             bool bIncludeUnmatched /* = true */ )
 208 {
 209
 210     // Assemble list of DAV properties to obtain from server.
 211     // Append DAV properties needed to obtain requested UCB props.
 212
 213
 214     //       DAV              UCB
 215     // creationdate     <- DateCreated
 216     // getlastmodified  <- DateModified
 217     // getcontenttype   <- MediaType
 218     // getcontentlength <- Size
 219     // resourcetype     <- IsFolder, IsDocument, ContentType
 220     // (taken from URI) <- Title
 221
 222     bool bCreationDate  = false;
 223     bool bLastModified  = false;
 224     bool bContentType   = false;
 225     bool bContentLength = false;
 226     bool bResourceType  = false;
 227
 228     sal_Int32 nCount = rProps.getLength();
 229     for ( sal_Int32 n = 0; n < nCount; ++n )
 230     {
 231         const beans::Property & rProp = rProps[ n ];
 232
 233         if ( rProp.Name == "Title" )
 234         {
 235             // Title is always obtained from resource's URI.
 236             continue;
 237         }
 238         else if ( rProp.Name == "DateCreated" ||
 239                   ( rProp.Name == DAVProperties::CREATIONDATE ) )
 240         {
 241             if ( !bCreationDate )
 242             {
 243                     propertyNames.push_back( DAVProperties::CREATIONDATE );
 244                 bCreationDate = true;
 245             }
 246         }
 247         else if ( rProp.Name == "DateModified" ||
 248                   ( rProp.Name == DAVProperties::GETLASTMODIFIED ) )
 249         {
 250             if ( !bLastModified )
 251             {
 252                     propertyNames.push_back(
 253                     DAVProperties::GETLASTMODIFIED );
 254                 bLastModified = true;
 255             }
 256         }
 257         else if ( rProp.Name == "MediaType" ||
 258                   ( rProp.Name == DAVProperties::GETCONTENTTYPE ) )
 259         {
 260             if ( !bContentType )
 261             {
 262                     propertyNames.push_back(
 263                         DAVProperties::GETCONTENTTYPE );
 264                 bContentType = true;
 265             }
 266         }
 267         else if ( rProp.Name == "Size" ||
 268                   ( rProp.Name == DAVProperties::GETCONTENTLENGTH ) )
 269         {
 270             if ( !bContentLength )
 271             {
 272                     propertyNames.push_back(
 273                     DAVProperties::GETCONTENTLENGTH );
 274                 bContentLength = true;
 275             }
 276         }
 277         else if ( rProp.Name == "ContentType" ||
 278                   rProp.Name == "IsDocument" ||
 279                   rProp.Name == "IsFolder" ||
 280                   ( rProp.Name == DAVProperties::RESOURCETYPE ) )
 281         {
 282             if ( !bResourceType )
 283             {
 284                     propertyNames.push_back( DAVProperties::RESOURCETYPE );
 285                 bResourceType = true;
 286             }
 287         }
 288         else
 289         {
 290             if ( bIncludeUnmatched )
 291                 propertyNames.push_back( rProp.Name );
 292         }
 293     }
 294 }
 295
 296
 297 // static
 298 void ContentProperties::UCBNamesToHTTPNames(
 299                             const uno::Sequence< beans::Property > & rProps,
 300                             std::vector< OUString > & propertyNames,
 301                             bool bIncludeUnmatched /* = true */ )
 302 {
 303
 304     // Assemble list of HTTP header names to obtain from server.
 305     // Append HTTP headers needed to obtain requested UCB props.
 306
 307
 308     //       HTTP              UCB
 309     // Last-Modified  <- DateModified
 310     // Content-Type   <- MediaType
 311     // Content-Length <- Size
 312
 313     sal_Int32 nCount = rProps.getLength();
 314     for ( sal_Int32 n = 0; n < nCount; ++n )
 315     {
 316         const beans::Property & rProp = rProps[ n ];
 317
 318         if ( rProp.Name == "DateModified" )
 319         {
 320             propertyNames.push_back( OUString( "Last-Modified" ) );
 321         }
 322         else if ( rProp.Name == "MediaType" )
 323         {
 324             propertyNames.push_back( OUString( "Content-Type" ) );
 325         }
 326         else if ( rProp.Name == "Size" )
 327         {
 328             propertyNames.push_back( OUString( "Content-Length" ) );
 329         }
 330         else
 331         {
 332             if ( bIncludeUnmatched )
 333                 propertyNames.push_back( rProp.Name );
 334         }
 335     }
 336 }
 337
 338
 339 bool ContentProperties::containsAllNames(
 340                     const uno::Sequence< beans::Property >& rProps,
 341                     std::vector< OUString > & rNamesNotContained ) const
 342 {
 343     rNamesNotContained.clear();
 344
 345     sal_Int32 nCount = rProps.getLength();
 346     for ( sal_Int32 n = 0; n < nCount; ++n )
 347     {
 348         const OUString & rName = rProps[ n ].Name;
 349         if ( !contains( rName ) )
 350         {
 351             // Not found.
 352             rNamesNotContained.push_back( rName );
 353         }
 354     }
 355
 356     return ( rNamesNotContained.size() == 0 );
 357 }
 358
 359
 360 void ContentProperties::addProperties(
 361                                 const std::vector< OUString > & rProps,
 362                                 const ContentProperties & rContentProps )
 363 {
 364     std::vector< OUString >::const_iterator it  = rProps.begin();
 365     std::vector< OUString >::const_iterator end = rProps.end();
 366
 367     while ( it != end )
 368     {
 369         const OUString & rName = (*it);
 370
 371         if ( !contains( rName ) ) // ignore duplicates
 372         {
 373             const PropertyValue * pProp = rContentProps.get( rName );
 374             if ( pProp )
 375             {
 376                 // Add it.
 377                 addProperty( rName, pProp->value(), pProp->isCaseSensitive() );
 378             }
 379             else
 380             {
 381                 addProperty( rName, uno::Any(), false );
 382             }
 383         }
 384         ++it;
 385     }
 386 }
 387
 388
 389 void ContentProperties::addProperties( const ContentProperties & rProps )
 390 {
 391     PropertyValueMap::const_iterator it = rProps.m_xProps->begin();
 392     const PropertyValueMap::const_iterator end = rProps.m_xProps->end();
 393
 394     while ( it != end )
 395     {
 396         addProperty(
 397             (*it).first, (*it).second.value(), (*it).second.isCaseSensitive() );
 398         ++it;
 399     }
 400 }
 401
 402
 403 void ContentProperties::addProperties(
 404     const std::vector< DAVPropertyValue > & rProps )
 405 {
 406     std::vector< DAVPropertyValue >::const_iterator it  = rProps.begin();
 407     const std::vector< DAVPropertyValue >::const_iterator end = rProps.end();
 408
 409     while ( it != end )
 410     {
 411         addProperty( (*it) );
 412         ++it;
 413     }
 414 }
 415
 416
 417 void ContentProperties::addProperty( const DAVPropertyValue & rProp )
 418 {
 419     addProperty( rProp.Name, rProp.Value, rProp.IsCaseSensitive );
 420 }
 421
 422
 423 void ContentProperties::addProperty( const OUString & rName,
 424                                      const com::sun::star::uno::Any & rValue,
 425                                      bool bIsCaseSensitive )
 426 {
 427     if ( rName == DAVProperties::CREATIONDATE )
 428     {
 429         // Map DAV:creationdate to UCP:DateCreated
 430         OUString aValue;
 431         rValue >>= aValue;
 432         util::DateTime aDate;
 433         DateTimeHelper::convert( aValue, aDate );
 434
 435         (*m_xProps)[ OUString( "DateCreated" ) ]
 436             = PropertyValue( uno::makeAny( aDate ), true );
 437     }
 438     //  else if ( rName.equals( DAVProperties::DISPLAYNAME ) )
 439     //  {
 440     //  }
 441     //  else if ( rName.equals( DAVProperties::GETCONTENTLANGUAGE ) )
 442     //  {
 443     //  }
 444     else if ( rName == DAVProperties::GETCONTENTLENGTH )
 445     {
 446         // Map DAV:getcontentlength to UCP:Size
 447         OUString aValue;
 448         rValue >>= aValue;
 449
 450         (*m_xProps)[ OUString( "Size" ) ]
 451             = PropertyValue( uno::makeAny( aValue.toInt64() ), true );
 452     }
 453     else if ( rName == "Content-Length" )
 454     {
 455         // Do NOT map Content-Length entity header to DAV:getcontentlength!
 456         // Only DAV resources have this property.
 457
 458         // Map Content-Length entity header to UCP:Size
 459         OUString aValue;
 460         rValue >>= aValue;
 461
 462         (*m_xProps)[ OUString( "Size" ) ]
 463             = PropertyValue( uno::makeAny( aValue.toInt64() ), true );
 464     }
 465     else if ( rName == DAVProperties::GETCONTENTTYPE )
 466     {
 467         // Map DAV:getcontenttype to UCP:MediaType (1:1)
 468         (*m_xProps)[ OUString( "MediaType" ) ]
 469             = PropertyValue( rValue, true );
 470     }
 471     else if ( rName == "Content-Type" )
 472     {
 473         // Do NOT map Content-Type entity header to DAV:getcontenttype!
 474         // Only DAV resources have this property.
 475
 476         // Map DAV:getcontenttype to UCP:MediaType (1:1)
 477         (*m_xProps)[ OUString( "MediaType" ) ]
 478             = PropertyValue( rValue, true );
 479     }
 480     //  else if ( rName.equals( DAVProperties::GETETAG ) )
 481     //  {
 482     //  }
 483     else if ( rName == DAVProperties::GETLASTMODIFIED )
 484     {
 485         // Map the DAV:getlastmodified entity header to UCP:DateModified
 486         OUString aValue;
 487         rValue >>= aValue;
 488         util::DateTime aDate;
 489         DateTimeHelper::convert( aValue, aDate );
 490
 491         (*m_xProps)[ OUString( "DateModified" ) ]
 492             = PropertyValue( uno::makeAny( aDate ), true );
 493     }
 494     else if ( rName == "Last-Modified" )
 495     {
 496         // Do not map Last-Modified entity header to DAV:getlastmodified!
 497         // Only DAV resources have this property.
 498
 499         // Map the Last-Modified entity header to UCP:DateModified
 500         OUString aValue;
 501         rValue >>= aValue;
 502         util::DateTime aDate;
 503         DateTimeHelper::convert( aValue, aDate );
 504
 505         (*m_xProps)[ OUString( "DateModified" ) ]
 506             = PropertyValue( uno::makeAny( aDate ), true );
 507     }
 508     //  else if ( rName.equals( DAVProperties::LOCKDISCOVERY ) )
 509     //  {
 510     //  }
 511     else if ( rName == DAVProperties::RESOURCETYPE )
 512     {
 513         OUString aValue;
 514         rValue >>= aValue;
 515
 516         // Map DAV:resourceype to UCP:IsFolder, UCP:IsDocument, UCP:ContentType
 517         bool bFolder =
 518             aValue.equalsIgnoreAsciiCase( "collection" );
 519
 520         (*m_xProps)[ OUString( "IsFolder" ) ]
 521             = PropertyValue( uno::makeAny( bFolder ), true );
 522         (*m_xProps)[ OUString( "IsDocument" ) ]
 523             = PropertyValue( uno::makeAny( bool( !bFolder ) ), true );
 524         (*m_xProps)[ OUString( "ContentType" ) ]
 525             = PropertyValue( uno::makeAny( bFolder
 526                 ? OUString( WEBDAV_COLLECTION_TYPE )
 527                 : OUString( WEBDAV_CONTENT_TYPE ) ), true );
 528     }
 529     //  else if ( rName.equals( DAVProperties::SUPPORTEDLOCK ) )
 530     //  {
 531     //  }
 532
 533     // Save property.
 534     (*m_xProps)[ rName ] = PropertyValue( rValue, bIsCaseSensitive );
 535 }
 536
 537
 538
 539
 540 // CachableContentProperties Implementation.
 541
 542
 543
 544
 545 namespace
 546 {
 547     bool isCachable( OUString const & rName,
 548                      bool isCaseSensitive )
 549     {
 550         static const OUString aNonCachableProps [] =
 551         {
 552             DAVProperties::LOCKDISCOVERY,
 553
 554             DAVProperties::GETETAG,
 555             OUString( "ETag" ),
 556
 557             OUString( "DateModified" ),
 558             OUString( "Last-Modified" ),
 559             DAVProperties::GETLASTMODIFIED,
 560
 561             OUString( "Size" ),
 562             OUString( "Content-Length" ),
 563             DAVProperties::GETCONTENTLENGTH,
 564
 565             OUString( "Date" )
 566         };
 567
 568         for ( sal_uInt32 n = 0;
 569               n <  ( sizeof( aNonCachableProps )
 570                      / sizeof( aNonCachableProps[ 0 ] ) );
 571               ++n )
 572         {
 573             if ( isCaseSensitive )
 574             {
 575                 if ( rName.equals( aNonCachableProps[ n ] ) )
 576                     return false;
 577             }
 578             else
 579                 if ( rName.equalsIgnoreAsciiCase( aNonCachableProps[ n ] ) )
 580                     return false;
 581         }
 582         return true;
 583     }
 584
 585 } // namespace
 586
 587
 588 CachableContentProperties::CachableContentProperties(
 589     const ContentProperties & rProps )
 590 {
 591     addProperties( rProps );
 592 }
 593
 594
 595 void CachableContentProperties::addProperties(
 596     const ContentProperties & rProps )
 597 {
 598     const boost::scoped_ptr< PropertyValueMap > & props = rProps.getProperties();
 599
 600     PropertyValueMap::const_iterator it = props->begin();
 601     const PropertyValueMap::const_iterator end = props->end();
 602
 603     while ( it != end )
 604     {
 605         if ( isCachable( (*it).first, (*it).second.isCaseSensitive() ) )
 606             m_aProps.addProperty( (*it).first,
 607                                   (*it).second.value(),
 608                                   (*it).second.isCaseSensitive() );
 609
 610         ++it;
 611     }
 612 }
 613
 614
 615 void CachableContentProperties::addProperties(
 616     const std::vector< DAVPropertyValue > & rProps )
 617 {
 618     std::vector< DAVPropertyValue >::const_iterator it  = rProps.begin();
 619     const std::vector< DAVPropertyValue >::const_iterator end = rProps.end();
 620
 621     while ( it != end )
 622     {
 623         if ( isCachable( (*it).Name, (*it).IsCaseSensitive ) )
 624             m_aProps.addProperty( (*it) );
 625
 626         ++it;
 627      }
 628 }
 629
 630 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */