ucb/source/ucp/webdav/webdavcontentcaps.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 <set>
  21 #include <com/sun/star/beans/Property.hpp>
  22 #include <com/sun/star/beans/PropertyAttribute.hpp>
  23 #include <com/sun/star/beans/PropertyValue.hpp>
  24 #include <com/sun/star/ucb/CommandInfo.hpp>
  25 #include <com/sun/star/ucb/ContentInfo.hpp>
  26 #include <com/sun/star/ucb/OpenCommandArgument2.hpp>
  27 #include <com/sun/star/ucb/InsertCommandArgument.hpp>
  28 #include <com/sun/star/ucb/PostCommandArgument2.hpp>
  29 #include <com/sun/star/ucb/PropertyCommandArgument.hpp>
  30 #include <com/sun/star/ucb/TransferInfo.hpp>
  31 #include <com/sun/star/uno/Sequence.hxx>
  32 #include <com/sun/star/util/DateTime.hpp>
  33 #include <com/sun/star/ucb/Lock.hpp>
  34 #include <com/sun/star/ucb/LockEntry.hpp>
  35 #include "webdavcontent.hxx"
  36 #include "webdavprovider.hxx"
  37 #include "DAVSession.hxx"
  38 #include "ContentProperties.hxx"
  39
  40 using namespace com::sun::star;
  41 using namespace http_dav_ucp;
  42
  43
  44
  45 // ContentProvider implementation.
  46
  47
  48
  49 bool ContentProvider::getProperty(
  50         const OUString & rPropName, beans::Property & rProp, bool bStrict )
  51 {
  52     if ( !m_pProps )
  53     {
  54         osl::MutexGuard aGuard( m_aMutex );
  55         if ( !m_pProps )
  56         {
  57             m_pProps = new PropertyMap;
  58
  59
  60             // Fill map of known properties...
  61
  62
  63             // Mandatory UCB properties.
  64             m_pProps->insert(
  65                 beans::Property(
  66                     OUString( "ContentType" ),
  67                     -1,
  68                     cppu::UnoType<OUString>::get(),
  69                     beans::PropertyAttribute::BOUND
  70                         | beans::PropertyAttribute::READONLY ) );
  71
  72             m_pProps->insert(
  73                 beans::Property(
  74                     OUString( "IsDocument" ),
  75                     -1,
  76                     cppu::UnoType<bool>::get(),
  77                     beans::PropertyAttribute::BOUND
  78                         | beans::PropertyAttribute::READONLY ) );
  79
  80             m_pProps->insert(
  81                 beans::Property(
  82                     OUString( "IsFolder" ),
  83                     -1,
  84                     cppu::UnoType<bool>::get(),
  85                     beans::PropertyAttribute::BOUND
  86                         | beans::PropertyAttribute::READONLY ) );
  87
  88             m_pProps->insert(
  89                 beans::Property(
  90                     OUString( "Title" ),
  91                     -1,
  92                     cppu::UnoType<OUString>::get(),
  93                     beans::PropertyAttribute::BOUND ) );
  94
  95             // Optional UCB properties.
  96
  97             m_pProps->insert(
  98                 beans::Property(
  99                     OUString( "DateCreated" ),
 100                     -1,
 101                     cppu::UnoType<util::DateTime>::get(),
 102                     beans::PropertyAttribute::BOUND
 103                         | beans::PropertyAttribute::READONLY ) );
 104
 105             m_pProps->insert(
 106                 beans::Property(
 107                     OUString( "DateModified" ),
 108                     -1,
 109                     cppu::UnoType<util::DateTime>::get(),
 110                     beans::PropertyAttribute::BOUND
 111                         | beans::PropertyAttribute::READONLY ) );
 112
 113             m_pProps->insert(
 114                 beans::Property(
 115                     OUString( "MediaType" ),
 116                     -1,
 117                     cppu::UnoType<OUString>::get(),
 118                     beans::PropertyAttribute::BOUND
 119                         | beans::PropertyAttribute::READONLY ) );
 120
 121             m_pProps->insert(
 122                 beans::Property(
 123                     OUString( "Size" ),
 124                     -1,
 125                     cppu::UnoType<sal_Int64>::get(),
 126                     beans::PropertyAttribute::BOUND
 127                         | beans::PropertyAttribute::READONLY ) );
 128
 129             m_pProps->insert(
 130                 beans::Property(
 131                     OUString( "BaseURI" ),
 132                     -1,
 133                     cppu::UnoType<OUString>::get(),
 134                     beans::PropertyAttribute::BOUND
 135                         | beans::PropertyAttribute::READONLY ) );
 136
 137             m_pProps->insert(
 138                 beans::Property(
 139                     OUString(
 140                         "CreatableContentsInfo" ),
 141                     -1,
 142                     cppu::UnoType<uno::Sequence< ucb::ContentInfo >>::get(),
 143                     beans::PropertyAttribute::BOUND
 144                         | beans::PropertyAttribute::READONLY ) );
 145
 146             // Standard DAV properties.
 147
 148             m_pProps->insert(
 149                 beans::Property(
 150                     DAVProperties::CREATIONDATE,
 151                     -1,
 152                     cppu::UnoType<OUString>::get(),
 153                     beans::PropertyAttribute::BOUND
 154                         | beans::PropertyAttribute::READONLY ) );
 155
 156             m_pProps->insert(
 157                 beans::Property(
 158                     DAVProperties::DISPLAYNAME,
 159                     -1,
 160                     cppu::UnoType<OUString>::get(),
 161                     beans::PropertyAttribute::BOUND ) );
 162
 163             m_pProps->insert(
 164                 beans::Property(
 165                     DAVProperties::GETCONTENTLANGUAGE,
 166                     -1,
 167                     cppu::UnoType<OUString>::get(),
 168                     beans::PropertyAttribute::BOUND
 169                         | beans::PropertyAttribute::READONLY ) );
 170
 171             m_pProps->insert(
 172                 beans::Property(
 173                     DAVProperties::GETCONTENTLENGTH,
 174                     -1,
 175                     cppu::UnoType<OUString>::get(),
 176                     beans::PropertyAttribute::BOUND
 177                         | beans::PropertyAttribute::READONLY ) );
 178
 179             m_pProps->insert(
 180                 beans::Property(
 181                     DAVProperties::GETCONTENTTYPE ,
 182                     -1,
 183                     cppu::UnoType<OUString>::get(),
 184                     beans::PropertyAttribute::BOUND
 185                         | beans::PropertyAttribute::READONLY ) );
 186
 187             m_pProps->insert(
 188                 beans::Property(
 189                     DAVProperties::GETETAG,
 190                     -1,
 191                     cppu::UnoType<OUString>::get(),
 192                     beans::PropertyAttribute::BOUND
 193                         | beans::PropertyAttribute::READONLY ) );
 194
 195             m_pProps->insert(
 196                 beans::Property(
 197                     DAVProperties::GETLASTMODIFIED,
 198                     -1,
 199                     cppu::UnoType<OUString>::get(),
 200                     beans::PropertyAttribute::BOUND
 201                         | beans::PropertyAttribute::READONLY ) );
 202
 203             m_pProps->insert(
 204                 beans::Property(
 205                     DAVProperties::LOCKDISCOVERY,
 206                     -1,
 207                     cppu::UnoType<uno::Sequence< ucb::Lock >>::get(),
 208                     beans::PropertyAttribute::BOUND
 209                         | beans::PropertyAttribute::READONLY ) );
 210
 211             m_pProps->insert(
 212                 beans::Property(
 213                     DAVProperties::RESOURCETYPE,
 214                     -1,
 215                     cppu::UnoType<OUString>::get(),
 216                     beans::PropertyAttribute::BOUND
 217                         | beans::PropertyAttribute::READONLY ) );
 218
 219             m_pProps->insert(
 220                 beans::Property(
 221                     DAVProperties::SUPPORTEDLOCK,
 222                     -1,
 223                     cppu::UnoType<uno::Sequence< ucb::LockEntry >>::get(),
 224                     beans::PropertyAttribute::BOUND
 225                         | beans::PropertyAttribute::READONLY ) );
 226
 227             m_pProps->insert(
 228                 beans::Property(
 229                     DAVProperties::EXECUTABLE,
 230                     -1,
 231                     cppu::UnoType<OUString>::get(),
 232                     beans::PropertyAttribute::BOUND ) );
 233         }
 234     }
 235
 236
 237     // Lookup property.
 238
 239
 240     beans::Property aProp;
 241     aProp.Name = rPropName;
 242     const PropertyMap::const_iterator it = m_pProps->find( aProp );
 243     if ( it != m_pProps->end() )
 244     {
 245         rProp = (*it);
 246     }
 247     else
 248     {
 249         if ( bStrict )
 250             return false;
 251
 252         // All unknown props are treated as:
 253         rProp = beans::Property(
 254                     rPropName,
 255                     - 1,
 256                     cppu::UnoType<OUString>::get(),
 257                     beans::PropertyAttribute::BOUND );
 258     }
 259
 260     return true;
 261 }
 262
 263
 264
 265 // Content implementation.
 266
 267
 268
 269 // virtual
 270 uno::Sequence< beans::Property > Content::getProperties(
 271     const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 272 {
 273     bool bTransient;
 274     boost::scoped_ptr< DAVResourceAccess > xResAccess;
 275     boost::scoped_ptr< ContentProperties > xCachedProps;
 276     rtl::Reference< ContentProvider >  xProvider;
 277
 278     {
 279         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 280
 281         bTransient = m_bTransient;
 282         xResAccess.reset( new DAVResourceAccess( *m_xResAccess.get() ) );
 283         if ( m_xCachedProps.get() )
 284             xCachedProps.reset(
 285                 new ContentProperties( *m_xCachedProps.get() ) );
 286         xProvider.set( m_pProvider );
 287     }
 288
 289     typedef std::set< OUString > StringSet;
 290     StringSet aPropSet;
 291
 292     // No server access for just created (not yet committed) objects.
 293     // Only a minimal set of properties supported at this stage.
 294     if ( !bTransient )
 295     {
 296         // Obtain all properties supported for this resource from server.
 297         try
 298         {
 299             std::vector< DAVResourceInfo > props;
 300             xResAccess->PROPFIND( DAVZERO, props, xEnv );
 301
 302             // Note: vector always contains exactly one resource info, because
 303             //       we used a depth of DAVZERO for PROPFIND.
 304             aPropSet.insert( (*props.begin()).properties.begin(),
 305                              (*props.begin()).properties.end() );
 306         }
 307         catch ( DAVException const & )
 308         {
 309         }
 310     }
 311
 312     // Add DAV properties, map DAV properties to UCB properties.
 313     bool bHasCreationDate     = false; // creationdate     <-> DateCreated
 314     bool bHasGetLastModified  = false; // getlastmodified  <-> DateModified
 315     bool bHasGetContentType   = false; // getcontenttype   <-> MediaType
 316     bool bHasGetContentLength = false; // getcontentlength <-> Size
 317
 318     bool bHasContentType      = false;
 319     bool bHasIsDocument       = false;
 320     bool bHasIsFolder         = false;
 321     bool bHasTitle            = false;
 322     bool bHasBaseURI          = false;
 323     bool bHasDateCreated      = false;
 324     bool bHasDateModified     = false;
 325     bool bHasMediaType        = false;
 326     bool bHasSize             = false;
 327     bool bHasCreatableInfos   = false;
 328
 329     {
 330         std::set< OUString >::const_iterator it  = aPropSet.begin();
 331         std::set< OUString >::const_iterator end = aPropSet.end();
 332         while ( it != end )
 333         {
 334             if ( !bHasCreationDate &&
 335                  ( (*it) == DAVProperties::CREATIONDATE ) )
 336             {
 337                 bHasCreationDate = true;
 338             }
 339             else if ( !bHasGetLastModified &&
 340                       ( (*it) == DAVProperties::GETLASTMODIFIED ) )
 341             {
 342                 bHasGetLastModified = true;
 343             }
 344             else if ( !bHasGetContentType &&
 345                       ( (*it) == DAVProperties::GETCONTENTTYPE ) )
 346             {
 347                 bHasGetContentType = true;
 348             }
 349             else if ( !bHasGetContentLength &&
 350                       ( (*it) == DAVProperties::GETCONTENTLENGTH ) )
 351             {
 352                 bHasGetContentLength = true;
 353             }
 354             else if ( !bHasContentType && (*it) == "ContentType" )
 355             {
 356                 bHasContentType = true;
 357             }
 358             else if ( !bHasIsDocument && (*it) == "IsDocument" )
 359             {
 360                 bHasIsDocument = true;
 361             }
 362             else if ( !bHasIsFolder && (*it) == "IsFolder" )
 363             {
 364                 bHasIsFolder = true;
 365             }
 366             else if ( !bHasTitle && (*it) == "Title" )
 367             {
 368                 bHasTitle = true;
 369             }
 370             else if ( !bHasBaseURI && (*it) == "BaseURI" )
 371             {
 372                 bHasBaseURI = true;
 373             }
 374             else if ( !bHasDateCreated && (*it) == "DateCreated" )
 375             {
 376                 bHasDateCreated = true;
 377             }
 378             else if ( !bHasDateModified && (*it) == "DateModified" )
 379             {
 380                 bHasDateModified = true;
 381             }
 382             else if ( !bHasMediaType && (*it) == "MediaType" )
 383             {
 384                 bHasMediaType = true;
 385             }
 386             else if ( !bHasSize && (*it) == "Size" )
 387             {
 388                 bHasSize = true;
 389             }
 390             else if ( !bHasCreatableInfos && (*it) == "CreatableContentsInfo" )
 391             {
 392                 bHasCreatableInfos = true;
 393             }
 394             ++it;
 395         }
 396     }
 397
 398     // Add mandatory properties.
 399     if ( !bHasContentType )
 400         aPropSet.insert(
 401             OUString( "ContentType" ) );
 402
 403     if ( !bHasIsDocument )
 404         aPropSet.insert(
 405             OUString( "IsDocument" ) );
 406
 407     if ( !bHasIsFolder )
 408         aPropSet.insert(
 409             OUString( "IsFolder" ) );
 410
 411     if ( !bHasTitle )
 412     {
 413         // Always present since it can be calculated from content's URI.
 414         aPropSet.insert(
 415             OUString( "Title" ) );
 416     }
 417
 418     // Add optional properties.
 419
 420     if ( !bHasBaseURI )
 421     {
 422         // Always present since it can be calculated from content's URI.
 423         aPropSet.insert(
 424             OUString( "BaseURI" ) );
 425     }
 426
 427     if ( !bHasDateCreated && bHasCreationDate )
 428         aPropSet.insert(
 429             OUString( "DateCreated" ) );
 430
 431     if ( !bHasDateModified && bHasGetLastModified )
 432         aPropSet.insert(
 433             OUString( "DateModified" ) );
 434
 435     if ( !bHasMediaType && bHasGetContentType )
 436         aPropSet.insert(
 437             OUString( "MediaType" ) );
 438
 439     if ( !bHasSize && bHasGetContentLength )
 440         aPropSet.insert(
 441             OUString( "Size" ) );
 442
 443     if ( !bHasCreatableInfos )
 444         aPropSet.insert(
 445             OUString(
 446                 "CreatableContentsInfo" ) );
 447
 448     // Add cached properties, if present and still missing.
 449     if ( xCachedProps.get() )
 450     {
 451         const std::set< OUString >::const_iterator set_end
 452             = aPropSet.end();
 453
 454         const boost::scoped_ptr< PropertyValueMap > & xProps
 455             = xCachedProps->getProperties();
 456
 457         PropertyValueMap::const_iterator       map_it  = xProps->begin();
 458         const PropertyValueMap::const_iterator map_end = xProps->end();
 459
 460         while ( map_it != map_end )
 461         {
 462             if ( aPropSet.find( (*map_it).first ) == set_end )
 463                 aPropSet.insert( (*map_it).first );
 464
 465             ++map_it;
 466         }
 467     }
 468
 469     // std::set -> uno::Sequence
 470     sal_Int32 nCount = aPropSet.size();
 471     uno::Sequence< beans::Property > aProperties( nCount );
 472
 473     std::set< OUString >::const_iterator it = aPropSet.begin();
 474     beans::Property aProp;
 475
 476     for ( sal_Int32 n = 0; n < nCount; ++n, ++it )
 477     {
 478         xProvider->getProperty( (*it), aProp );
 479         aProperties[ n ] = aProp;
 480     }
 481
 482     return aProperties;
 483 }
 484
 485
 486 // virtual
 487 uno::Sequence< ucb::CommandInfo > Content::getCommands(
 488     const uno::Reference< ucb::XCommandEnvironment > & xEnv )
 489 {
 490     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 491
 492     uno::Sequence< ucb::CommandInfo > aCmdInfo( 10 );
 493
 494
 495     // Mandatory commands
 496
 497
 498     aCmdInfo[ 0 ] =
 499             ucb::CommandInfo(
 500                 OUString( "getCommandInfo" ),
 501                 -1,
 502                 cppu::UnoType<void>::get() );
 503     aCmdInfo[ 1 ] =
 504             ucb::CommandInfo(
 505                 OUString( "getPropertySetInfo" ),
 506                 -1,
 507                 cppu::UnoType<void>::get() );
 508     aCmdInfo[ 2 ] =
 509             ucb::CommandInfo(
 510                 OUString( "getPropertyValues" ),
 511                 -1,
 512                 cppu::UnoType<uno::Sequence< beans::Property >>::get());
 513     aCmdInfo[ 3 ] =
 514             ucb::CommandInfo(
 515                 OUString( "setPropertyValues" ),
 516                 -1,
 517                 cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get());
 518
 519
 520     // Optional standard commands
 521
 522
 523     aCmdInfo[ 4 ] =
 524             ucb::CommandInfo(
 525                 OUString( "delete" ),
 526                 -1,
 527                 cppu::UnoType<bool>::get() );
 528     aCmdInfo[ 5 ] =
 529             ucb::CommandInfo(
 530                 OUString( "insert" ),
 531                 -1,
 532                 cppu::UnoType<ucb::InsertCommandArgument>::get() );
 533     aCmdInfo[ 6 ] =
 534             ucb::CommandInfo(
 535                 OUString( "open" ),
 536                 -1,
 537                 cppu::UnoType<ucb::OpenCommandArgument2>::get() );
 538
 539
 540     // New commands
 541
 542
 543     aCmdInfo[ 7 ] =
 544             ucb::CommandInfo(
 545                 OUString( "post" ),
 546                 -1,
 547                 cppu::UnoType<ucb::PostCommandArgument2>::get() );
 548     aCmdInfo[ 8 ] =
 549             ucb::CommandInfo(
 550                 OUString( "addProperty" ),
 551                 -1,
 552                 cppu::UnoType<ucb::PropertyCommandArgument>::get() );
 553     aCmdInfo[ 9 ] =
 554             ucb::CommandInfo(
 555                 OUString( "removeProperty" ),
 556                 -1,
 557                 cppu::UnoType<rtl::OUString>::get() );
 558
 559     bool bFolder = false;
 560
 561     try
 562     {
 563         bFolder = isFolder( xEnv );
 564     }
 565     catch ( uno::Exception const & )
 566     {
 567         return aCmdInfo;
 568     }
 569
 570     bool bSupportsLocking = supportsExclusiveWriteLock( xEnv );
 571
 572     sal_Int32 nPos = aCmdInfo.getLength();
 573     sal_Int32 nMoreCmds = ( bFolder ? 2 : 0 ) + ( bSupportsLocking ? 2 : 0 );
 574     if ( nMoreCmds )
 575         aCmdInfo.realloc( nPos + nMoreCmds );
 576     else
 577         return aCmdInfo;
 578
 579     if ( bFolder )
 580     {
 581
 582         // Optional standard commands
 583
 584
 585         aCmdInfo[ nPos ] =
 586             ucb::CommandInfo(
 587                 OUString( "transfer" ),
 588                 -1,
 589                 cppu::UnoType<ucb::TransferInfo>::get() );
 590         nPos++;
 591         aCmdInfo[ nPos ] =
 592             ucb::CommandInfo(
 593                 OUString(
 594                     "createNewContent" ),
 595                 -1,
 596                 cppu::UnoType<ucb::ContentInfo>::get() );
 597         nPos++;
 598     }
 599     else
 600     {
 601         // no document-only commands at the moment.
 602     }
 603
 604     if ( bSupportsLocking )
 605     {
 606         aCmdInfo[ nPos ] =
 607             ucb::CommandInfo(
 608                 OUString( "lock" ),
 609                 -1,
 610                 cppu::UnoType<void>::get() );
 611         nPos++;
 612         aCmdInfo[ nPos ] =
 613             ucb::CommandInfo(
 614                 OUString( "unlock" ),
 615                 -1,
 616                 cppu::UnoType<void>::get() );
 617         nPos++;
 618     }
 619     return aCmdInfo;
 620 }
 621
 622 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */