ucb/source/ucp/cmis/cmis_datasupplier.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * Copyright 2012 LibreOffice contributors.
   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
  10 #include <vector>
  11
  12 #include <ucbhelper/contentidentifier.hxx>
  13 #include <ucbhelper/providerhelper.hxx>
  14
  15 #include <com/sun/star/ucb/OpenMode.hpp>
  16
  17 #include "cmis_datasupplier.hxx"
  18 #include "cmis_content.hxx"
  19 #include "cmis_provider.hxx"
  20
  21 #define STD_TO_OUSTR( str ) rtl::OUString( str.c_str(), str.length( ), RTL_TEXTENCODING_UTF8 )
  22
  23 using namespace com::sun::star;
  24 using namespace std;
  25
  26 namespace cmis
  27 {
  28
  29     typedef std::vector< ResultListEntry* > ResultList;
  30
  31     DataSupplier::DataSupplier( const uno::Reference< lang::XMultiServiceFactory >& rxSMgr,
  32         const uno::Reference< ::cmis::Content >& rContent, sal_Int32 nOpenMode )
  33         : mxContent(rContent), m_xSMgr(rxSMgr), mnOpenMode(nOpenMode), mbCountFinal(false)
  34     {
  35     }
  36
  37     bool DataSupplier::getData()
  38     {
  39         if ( mbCountFinal )
  40             return true;
  41
  42         libcmis::ObjectPtr pObject = mxContent->getObject();
  43         libcmis::Folder* pFolder = dynamic_cast< libcmis::Folder* >( pObject.get( ) );
  44         if ( NULL != pFolder )
  45         {
  46             // Get the children from pObject
  47             try
  48             {
  49                 vector< libcmis::ObjectPtr > children = pFolder->getChildren( );
  50
  51                 // Loop over the results and filter them
  52                 for ( vector< libcmis::ObjectPtr >::iterator it = children.begin();
  53                         it != children.end(); ++it )
  54                 {
  55                     bool bIsFolder = ( *it )->getBaseType( ) == "cmis:folder";
  56                     if ( ( mnOpenMode == ucb::OpenMode::FOLDERS && bIsFolder ) ||
  57                          ( mnOpenMode == ucb::OpenMode::DOCUMENTS && !bIsFolder ) ||
  58                          ( mnOpenMode == ucb::OpenMode::ALL ) )
  59                     {
  60                         maResults.push_back( new ResultListEntry( *it ) );
  61                     }
  62                 }
  63                 mbCountFinal = sal_True;
  64
  65                 return true;
  66             }
  67             catch ( const libcmis::Exception& e )
  68             {
  69                 SAL_INFO( "cmisucp", "Exception thrown: " << e.what() );
  70                 return false;
  71             }
  72         }
  73
  74         return false;
  75     }
  76
  77     DataSupplier::~DataSupplier()
  78     {
  79     }
  80
  81     ::rtl::OUString DataSupplier::queryContentIdentifierString( sal_uInt32 nIndex )
  82     {
  83         if ( nIndex < maResults.size() )
  84         {
  85             ::rtl::OUString aId = maResults[ nIndex ]->aId;
  86             if ( aId.getLength() )
  87             {
  88                 // Already cached.
  89                 return aId;
  90             }
  91         }
  92
  93         if ( getResult( nIndex ) )
  94         {
  95             string sObjectPath;
  96             vector< string > paths = maResults[nIndex]->pObject->getPaths( );
  97             if ( paths.size( ) > 0 )
  98                 sObjectPath = paths.front( );
  99             else
 100             {
 101                 // Handle the unfiled objects with their id...
 102                 // They manage to sneak here if we don't have the permission to get the object
 103                 // parents (and then the path)
 104                 sObjectPath += "#" + maResults[nIndex]->pObject->getId( );
 105             }
 106
 107             // Get the URL from the Path
 108             URL aUrl( mxContent->getIdentifier( )->getContentIdentifier( ) );
 109             aUrl.setObjectPath( STD_TO_OUSTR( sObjectPath ) );
 110             rtl::OUString aId = aUrl.asString( );
 111
 112             maResults[ nIndex ]->aId = aId;
 113             return aId;
 114         }
 115
 116         return ::rtl::OUString();
 117     }
 118
 119     uno::Reference< ucb::XContentIdentifier > DataSupplier::queryContentIdentifier( sal_uInt32 nIndex )
 120     {
 121         if ( nIndex < maResults.size() )
 122         {
 123             uno::Reference< ucb::XContentIdentifier > xId = maResults[ nIndex ]->xId;
 124             if ( xId.is() )
 125             {
 126                 // Already cached.
 127                 return xId;
 128             }
 129         }
 130
 131         ::rtl::OUString aId = queryContentIdentifierString( nIndex );
 132         if ( aId.getLength() )
 133         {
 134             uno::Reference< ucb::XContentIdentifier > xId = new ucbhelper::ContentIdentifier( aId );
 135             maResults[ nIndex ]->xId = xId;
 136             return xId;
 137         }
 138
 139         return uno::Reference< ucb::XContentIdentifier >();
 140     }
 141
 142     uno::Reference< ucb::XContent > DataSupplier::queryContent( sal_uInt32 nIndex )
 143     {
 144         if ( nIndex < maResults.size() )
 145         {
 146             uno::Reference< ucb::XContent > xContent = maResults[ nIndex ]->xContent;
 147             if ( xContent.is() )
 148             {
 149                 // Already cached.
 150                 return xContent;
 151             }
 152         }
 153
 154         uno::Reference< ucb::XContentIdentifier > xId = queryContentIdentifier( nIndex );
 155         if ( xId.is() )
 156         {
 157             try
 158             {
 159                 uno::Reference< ucb::XContent > xContent = mxContent->getProvider()->queryContent( xId );
 160                 maResults[ nIndex ]->xContent = xContent;
 161                 return xContent;
 162             }
 163             catch ( ucb::IllegalIdentifierException& )
 164             {
 165             }
 166         }
 167         return uno::Reference< ucb::XContent >();
 168     }
 169
 170     sal_Bool DataSupplier::getResult( sal_uInt32 nIndex )
 171     {
 172         if ( maResults.size() > nIndex ) // Result already present.
 173             return sal_True;
 174
 175         if ( getData() && maResults.size() > nIndex )
 176             return sal_True;
 177
 178         return sal_False;
 179     }
 180
 181     sal_uInt32 DataSupplier::totalCount()
 182     {
 183         getData();
 184         return maResults.size();
 185     }
 186
 187     sal_uInt32 DataSupplier::currentCount()
 188     {
 189         return maResults.size();
 190     }
 191
 192     sal_Bool DataSupplier::isCountFinal()
 193     {
 194         return mbCountFinal;
 195     }
 196
 197     uno::Reference< sdbc::XRow > DataSupplier::queryPropertyValues( sal_uInt32 nIndex  )
 198     {
 199         if ( nIndex < maResults.size() )
 200         {
 201             uno::Reference< sdbc::XRow > xRow = maResults[ nIndex ]->xRow;
 202             if ( xRow.is() )
 203             {
 204                 // Already cached.
 205                 return xRow;
 206             }
 207         }
 208
 209         if ( getResult( nIndex ) )
 210         {
 211             uno::Reference< ucb::XContent > xContent( queryContent( nIndex ) );
 212             if ( xContent.is() )
 213             {
 214                 try
 215                 {
 216                     uno::Reference< ucb::XCommandProcessor > xCmdProc(
 217                         xContent, uno::UNO_QUERY_THROW );
 218                     sal_Int32 nCmdId( xCmdProc->createCommandIdentifier() );
 219                     ucb::Command aCmd;
 220                     aCmd.Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("getPropertyValues"));
 221                     aCmd.Handle = -1;
 222                     aCmd.Argument <<= getResultSet()->getProperties();
 223                     uno::Any aResult( xCmdProc->execute(
 224                         aCmd, nCmdId, getResultSet()->getEnvironment() ) );
 225                     uno::Reference< sdbc::XRow > xRow;
 226                     if ( aResult >>= xRow )
 227                     {
 228                         maResults[ nIndex ]->xRow = xRow;
 229                         return xRow;
 230                     }
 231                 }
 232                 catch ( uno::Exception const & )
 233                 {
 234                 }
 235             }
 236         }
 237         return uno::Reference< sdbc::XRow >();
 238     }
 239
 240     void DataSupplier::releasePropertyValues( sal_uInt32 nIndex )
 241     {
 242         if ( nIndex < maResults.size() )
 243             maResults[ nIndex ]->xRow = uno::Reference< sdbc::XRow >();
 244     }
 245
 246     void DataSupplier::close()
 247     {
 248     }
 249
 250     void DataSupplier::validate() throw( ucb::ResultSetException )
 251     {
 252     }
 253
 254 }
 255
 256 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */