?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 7.6.3.2-android
[LibreOffice.git] / ucb / source / ucp / cmis / cmis_content.cxx
blob52c4769e474bdf8ec88ec0dafa57d6644d6f57b3
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
10 #include <string_view>
11
12 #include <boost/make_shared.hpp>
13
14 #include <com/sun/star/beans/IllegalTypeException.hpp>
15 #include <com/sun/star/beans/PropertyAttribute.hpp>
16 #include <com/sun/star/beans/PropertyValue.hpp>
17 #include <com/sun/star/beans/XPropertySetInfo.hpp>
18 #include <com/sun/star/document/CmisProperty.hpp>
19 #include <com/sun/star/io/XActiveDataSink.hpp>
20 #include <com/sun/star/io/XActiveDataStreamer.hpp>
21 #include <com/sun/star/lang/IllegalAccessException.hpp>
22 #include <com/sun/star/lang/IllegalArgumentException.hpp>
23 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
24 #include <com/sun/star/task/InteractionClassification.hpp>
25 #include <com/sun/star/ucb/ContentInfo.hpp>
26 #include <com/sun/star/ucb/ContentInfoAttribute.hpp>
27 #include <com/sun/star/ucb/InsertCommandArgument2.hpp>
28 #include <com/sun/star/ucb/InteractiveBadTransferURLException.hpp>
29 #include <com/sun/star/ucb/InteractiveAugmentedIOException.hpp>
30 #include <com/sun/star/ucb/MissingInputStreamException.hpp>
31 #include <com/sun/star/ucb/OpenMode.hpp>
32 #include <com/sun/star/ucb/UnsupportedCommandException.hpp>
33 #include <com/sun/star/ucb/UnsupportedDataSinkException.hpp>
34 #include <com/sun/star/ucb/UnsupportedOpenModeException.hpp>
35 #include <com/sun/star/ucb/XCommandInfo.hpp>
36 #include <com/sun/star/ucb/XDynamicResultSet.hpp>
37 #ifndef SYSTEM_CURL
38 #include <com/sun/star/xml/crypto/XDigestContext.hpp>
39 #include <com/sun/star/xml/crypto/DigestID.hpp>
40 #include <com/sun/star/xml/crypto/NSSInitializer.hpp>
41 #endif
42
43 #include <comphelper/processfactory.hxx>
44 #include <comphelper/sequence.hxx>
45 #include <cppuhelper/exc_hlp.hxx>
46 #include <cppuhelper/queryinterface.hxx>
47 #include <config_oauth2.h>
48 #include <o3tl/runtimetooustring.hxx>
49 #include <sal/log.hxx>
50 #include <tools/urlobj.hxx>
51 #include <tools/long.hxx>
52 #include <ucbhelper/cancelcommandexecution.hxx>
53 #include <ucbhelper/content.hxx>
54 #include <ucbhelper/contentidentifier.hxx>
55 #include <ucbhelper/propertyvalueset.hxx>
56 #include <ucbhelper/proxydecider.hxx>
57 #include <ucbhelper/macros.hxx>
58 #include <sax/tools/converter.hxx>
59 #include <curlinit.hxx>
60
61 #include <utility>
62
63 #include "auth_provider.hxx"
64 #include "certvalidation_handler.hxx"
65 #include "cmis_content.hxx"
66 #include "cmis_provider.hxx"
67 #include "cmis_resultset.hxx"
68 #include "cmis_strings.hxx"
69 #include "std_inputstream.hxx"
70 #include "std_outputstream.hxx"
71
72 #define OUSTR_TO_STDSTR(s) std::string( OUStringToOString( s, RTL_TEXTENCODING_UTF8 ) )
73 #define STD_TO_OUSTR( str ) OStringToOUString( str, RTL_TEXTENCODING_UTF8 )
74
75 using namespace com::sun::star;
76
77 namespace
78 {
79 util::DateTime lcl_boostToUnoTime(const boost::posix_time::ptime& boostTime)
80 {
81 util::DateTime unoTime;
82 unoTime.Year = boostTime.date().year();
83 unoTime.Month = boostTime.date().month();
84 unoTime.Day = boostTime.date().day();
85 unoTime.Hours = boostTime.time_of_day().hours();
86 unoTime.Minutes = boostTime.time_of_day().minutes();
87 unoTime.Seconds = boostTime.time_of_day().seconds();
88
89 // TODO FIXME maybe we should compile with BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
90 // to actually get nanosecond precision in boostTime?
91 // use this way rather than total_nanos to avoid overflows with 32-bit long
92 const tools::Long ticks = boostTime.time_of_day().fractional_seconds();
93 tools::Long nanoSeconds = ticks * ( 1000000000 / boost::posix_time::time_duration::ticks_per_second());
94
95 unoTime.NanoSeconds = nanoSeconds;
96
97 return unoTime;
98 }
99
100 uno::Any lcl_cmisPropertyToUno( const libcmis::PropertyPtr& pProperty )
101 {
102 uno::Any aValue;
103 switch ( pProperty->getPropertyType( )->getType( ) )
104 {
105 default:
106 case libcmis::PropertyType::String:
107 {
108 auto aCmisStrings = pProperty->getStrings( );
109 uno::Sequence< OUString > aStrings( aCmisStrings.size( ) );
110 OUString* aStringsArr = aStrings.getArray( );
111 sal_Int32 i = 0;
112 for ( const auto& rCmisStr : aCmisStrings )
113 {
114 aStringsArr[i++] = STD_TO_OUSTR( rCmisStr );
115 }
116 aValue <<= aStrings;
117 }
118 break;
119 case libcmis::PropertyType::Integer:
120 {
121 auto aCmisLongs = pProperty->getLongs( );
122 uno::Sequence< sal_Int64 > aLongs( aCmisLongs.size( ) );
123 sal_Int64* aLongsArr = aLongs.getArray( );
124 sal_Int32 i = 0;
125 for ( const auto& rCmisLong : aCmisLongs )
126 {
127 aLongsArr[i++] = rCmisLong;
128 }
129 aValue <<= aLongs;
130 }
131 break;
132 case libcmis::PropertyType::Decimal:
133 {
134 auto aCmisDoubles = pProperty->getDoubles( );
135 uno::Sequence< double > aDoubles = comphelper::containerToSequence(aCmisDoubles);
136 aValue <<= aDoubles;
137 }
138 break;
139 case libcmis::PropertyType::Bool:
140 {
141 auto aCmisBools = pProperty->getBools( );
142 uno::Sequence< sal_Bool > aBools( aCmisBools.size( ) );
143 sal_Bool* aBoolsArr = aBools.getArray( );
144 sal_Int32 i = 0;
145 for ( bool bCmisBool : aCmisBools )
146 {
147 aBoolsArr[i++] = bCmisBool;
148 }
149 aValue <<= aBools;
150 }
151 break;
152 case libcmis::PropertyType::DateTime:
153 {
154 auto aCmisTimes = pProperty->getDateTimes( );
155 uno::Sequence< util::DateTime > aTimes( aCmisTimes.size( ) );
156 util::DateTime* aTimesArr = aTimes.getArray( );
157 sal_Int32 i = 0;
158 for ( const auto& rCmisTime : aCmisTimes )
159 {
160 aTimesArr[i++] = lcl_boostToUnoTime( rCmisTime );
161 }
162 aValue <<= aTimes;
163 }
164 break;
165 }
166 return aValue;
167 }
168
169 libcmis::PropertyPtr lcl_unoToCmisProperty(const document::CmisProperty& prop )
170 {
171 libcmis::PropertyTypePtr propertyType( new libcmis::PropertyType( ) );
172
173 OUString id = prop.Id;
174 OUString name = prop.Name;
175 bool bUpdatable = prop.Updatable;
176 bool bRequired = prop.Required;
177 bool bMultiValued = prop.MultiValued;
178 bool bOpenChoice = prop.OpenChoice;
179 uno::Any value = prop.Value;
180 std::vector< std::string > values;
181
182 libcmis::PropertyType::Type type = libcmis::PropertyType::String;
183 if ( prop.Type == CMIS_TYPE_STRING )
184 {
185 uno::Sequence< OUString > seqValue;
186 value >>= seqValue;
187 std::transform(std::cbegin(seqValue), std::cend(seqValue), std::back_inserter(values),
188 [](const OUString& rValue) -> std::string { return OUSTR_TO_STDSTR( rValue ); });
189 type = libcmis::PropertyType::String;
190 }
191 else if ( prop.Type == CMIS_TYPE_BOOL )
192 {
193 uno::Sequence< sal_Bool > seqValue;
194 value >>= seqValue;
195 std::transform(std::cbegin(seqValue), std::cend(seqValue), std::back_inserter(values),
196 [](const bool nValue) -> std::string { return std::string( OString::boolean( nValue ) ); });
197 type = libcmis::PropertyType::Bool;
198 }
199 else if ( prop.Type == CMIS_TYPE_INTEGER )
200 {
201 uno::Sequence< sal_Int64 > seqValue;
202 value >>= seqValue;
203 std::transform(std::cbegin(seqValue), std::cend(seqValue), std::back_inserter(values),
204 [](const sal_Int64 nValue) -> std::string { return std::string( OString::number( nValue ) ); });
205 type = libcmis::PropertyType::Integer;
206 }
207 else if ( prop.Type == CMIS_TYPE_DECIMAL )
208 {
209 uno::Sequence< double > seqValue;
210 value >>= seqValue;
211 std::transform(std::cbegin(seqValue), std::cend(seqValue), std::back_inserter(values),
212 [](const double fValue) -> std::string { return std::string( OString::number( fValue ) ); });
213 type = libcmis::PropertyType::Decimal;
214 }
215 else if ( prop.Type == CMIS_TYPE_DATETIME )
216 {
217 uno::Sequence< util::DateTime > seqValue;
218 value >>= seqValue;
219 std::transform(std::cbegin(seqValue), std::cend(seqValue), std::back_inserter(values),
220 [](const util::DateTime& rValue) -> std::string {
221 OUStringBuffer aBuffer;
222 ::sax::Converter::convertDateTime( aBuffer, rValue, nullptr );
223 return OUSTR_TO_STDSTR( aBuffer );
224 });
225 type = libcmis::PropertyType::DateTime;
226 }
227
228 propertyType->setId( OUSTR_TO_STDSTR( id ));
229 propertyType->setDisplayName( OUSTR_TO_STDSTR( name ) );
230 propertyType->setUpdatable( bUpdatable );
231 propertyType->setRequired( bRequired );
232 propertyType->setMultiValued( bMultiValued );
233 propertyType->setOpenChoice( bOpenChoice );
234 propertyType->setType( type );
235
236 libcmis::PropertyPtr property( new libcmis::Property( propertyType, std::move(values) ) );
237
238 return property;
239 }
240
241 uno::Sequence< uno::Any > generateErrorArguments( const cmis::URL & rURL )
242 {
243 uno::Sequence< uno::Any > aArguments{ uno::Any(beans::PropertyValue(
244 "Binding URL",
245 - 1,
246 uno::Any( rURL.getBindingUrl() ),
247 beans::PropertyState_DIRECT_VALUE )),
248 uno::Any(beans::PropertyValue(
249 "Username",
250 -1,
251 uno::Any( rURL.getUsername() ),
252 beans::PropertyState_DIRECT_VALUE )),
253 uno::Any(beans::PropertyValue(
254 "Repository Id",
255 -1,
256 uno::Any( rURL.getRepositoryId() ),
257 beans::PropertyState_DIRECT_VALUE )) };
258
259 return aArguments;
260 }
261 }
262
263 namespace cmis
264 {
265 Content::Content( const uno::Reference< uno::XComponentContext >& rxContext,
266 ContentProvider *pProvider, const uno::Reference< ucb::XContentIdentifier >& Identifier,
267 libcmis::ObjectPtr pObject )
268 : ContentImplHelper( rxContext, pProvider, Identifier ),
269 m_pProvider( pProvider ),
270 m_pSession( nullptr ),
271 m_pObject(std::move( pObject )),
272 m_sURL( Identifier->getContentIdentifier( ) ),
273 m_aURL( Identifier->getContentIdentifier( ) ),
274 m_bTransient( false ),
275 m_bIsFolder( false )
276 {
277 SAL_INFO( "ucb.ucp.cmis", "Content::Content() " << m_sURL );
278
279 m_sObjectPath = m_aURL.getObjectPath( );
280 m_sObjectId = m_aURL.getObjectId( );
281 }
282
283 Content::Content( const uno::Reference< uno::XComponentContext >& rxContext, ContentProvider *pProvider,
284 const uno::Reference< ucb::XContentIdentifier >& Identifier,
285 bool bIsFolder )
286 : ContentImplHelper( rxContext, pProvider, Identifier ),
287 m_pProvider( pProvider ),
288 m_pSession( nullptr ),
289 m_sURL( Identifier->getContentIdentifier( ) ),
290 m_aURL( Identifier->getContentIdentifier( ) ),
291 m_bTransient( true ),
292 m_bIsFolder( bIsFolder )
293 {
294 SAL_INFO( "ucb.ucp.cmis", "Content::Content() " << m_sURL );
295
296 m_sObjectPath = m_aURL.getObjectPath( );
297 m_sObjectId = m_aURL.getObjectId( );
298 }
299
300 Content::~Content()
301 {
302 }
303
304 libcmis::Session* Content::getSession( const uno::Reference< ucb::XCommandEnvironment >& xEnv )
305 {
306 // Set the proxy if needed. We are doing that all times as the proxy data shouldn't be cached.
307 ucbhelper::InternetProxyDecider aProxyDecider( m_xContext );
308 INetURLObject aBindingUrl( m_aURL.getBindingUrl( ) );
309 const ucbhelper::InternetProxyServer& rProxy = aProxyDecider.getProxy(
310 INetURLObject::GetScheme( aBindingUrl.GetProtocol( ) ), aBindingUrl.GetHost(), aBindingUrl.GetPort() );
311 OUString sProxy = rProxy.aName;
312 if ( rProxy.nPort > 0 )
313 sProxy += ":" + OUString::number( rProxy.nPort );
314 libcmis::SessionFactory::setProxySettings( OUSTR_TO_STDSTR( sProxy ), std::string(), std::string(), std::string() );
315
316 // Look for a cached session, key is binding url + repo id
317 OUString sSessionId = m_aURL.getBindingUrl( ) + m_aURL.getRepositoryId( );
318 if ( nullptr == m_pSession )
319 m_pSession = m_pProvider->getSession( sSessionId, m_aURL.getUsername( ) );
320
321 if ( nullptr == m_pSession )
322 {
323 #ifndef SYSTEM_CURL
324 // Initialize NSS library to make sure libcmis (and curl) can access CACERTs using NSS
325 // when using internal libcurl.
326 uno::Reference< css::xml::crypto::XNSSInitializer >
327 xNSSInitializer = css::xml::crypto::NSSInitializer::create( m_xContext );
328
329 uno::Reference< css::xml::crypto::XDigestContext > xDigestContext(
330 xNSSInitializer->getDigestContext( css::xml::crypto::DigestID::SHA256,
331 uno::Sequence< beans::NamedValue >() ),
332 uno::UNO_SET_THROW );
333 #endif
334
335 // Set the SSL Validation handler
336 libcmis::CertValidationHandlerPtr certHandler(
337 new CertValidationHandler( xEnv, m_xContext, aBindingUrl.GetHost( ) ) );
338 libcmis::SessionFactory::setCertificateValidationHandler( certHandler );
339
340 // init libcurl callback
341 libcmis::SessionFactory::setCurlInitProtocolsFunction(&::InitCurl_easy);
342
343 // Get the auth credentials
344 AuthProvider aAuthProvider(xEnv, m_xIdentifier->getContentIdentifier(), m_aURL.getBindingUrl());
345 AuthProvider::setXEnv( xEnv );
346
347 auto rUsername = OUSTR_TO_STDSTR( m_aURL.getUsername( ) );
348 auto rPassword = OUSTR_TO_STDSTR( m_aURL.getPassword( ) );
349
350 bool bSkipInitialPWAuth = false;
351 if (m_aURL.getBindingUrl() == ONEDRIVE_BASE_URL
352 || m_aURL.getBindingUrl() == GDRIVE_BASE_URL)
353 {
354 // skip the initial username and pw-auth prompt, the only supported method is the
355 // auth-code-fallback one (login with your browser, copy code into the dialog)
356 // TODO: if LO were to listen on localhost for the request, it would be much nicer
357 // user experience
358 bSkipInitialPWAuth = true;
359 rPassword = aAuthProvider.getRefreshToken(rUsername);
360 }
361
362 bool bIsDone = false;
363
364 while ( !bIsDone )
365 {
366 if (bSkipInitialPWAuth || aAuthProvider.authenticationQuery(rUsername, rPassword))
367 {
368 // Initiate a CMIS session and register it as we found nothing
369 libcmis::OAuth2DataPtr oauth2Data;
370 if ( m_aURL.getBindingUrl( ) == GDRIVE_BASE_URL )
371 {
372 // reset the skip, so user gets a chance to cancel
373 bSkipInitialPWAuth = false;
374 libcmis::SessionFactory::setOAuth2AuthCodeProvider(AuthProvider::copyWebAuthCodeFallback);
375 oauth2Data = boost::make_shared<libcmis::OAuth2Data>(
376 GDRIVE_AUTH_URL, GDRIVE_TOKEN_URL,
377 GDRIVE_SCOPE, GDRIVE_REDIRECT_URI,
378 GDRIVE_CLIENT_ID, GDRIVE_CLIENT_SECRET );
379 }
380 if ( m_aURL.getBindingUrl().startsWith( ALFRESCO_CLOUD_BASE_URL ) )
381 oauth2Data = boost::make_shared<libcmis::OAuth2Data>(
382 ALFRESCO_CLOUD_AUTH_URL, ALFRESCO_CLOUD_TOKEN_URL,
383 ALFRESCO_CLOUD_SCOPE, ALFRESCO_CLOUD_REDIRECT_URI,
384 ALFRESCO_CLOUD_CLIENT_ID, ALFRESCO_CLOUD_CLIENT_SECRET );
385 if ( m_aURL.getBindingUrl( ) == ONEDRIVE_BASE_URL )
386 {
387 // reset the skip, so user gets a chance to cancel
388 bSkipInitialPWAuth = false;
389 libcmis::SessionFactory::setOAuth2AuthCodeProvider(AuthProvider::copyWebAuthCodeFallback);
390 oauth2Data = boost::make_shared<libcmis::OAuth2Data>(
391 ONEDRIVE_AUTH_URL, ONEDRIVE_TOKEN_URL,
392 ONEDRIVE_SCOPE, ONEDRIVE_REDIRECT_URI,
393 ONEDRIVE_CLIENT_ID, ONEDRIVE_CLIENT_SECRET );
394 }
395 try
396 {
397 m_pSession = libcmis::SessionFactory::createSession(
398 OUSTR_TO_STDSTR( m_aURL.getBindingUrl( ) ),
399 rUsername, rPassword, OUSTR_TO_STDSTR( m_aURL.getRepositoryId( ) ), false, oauth2Data );
400
401 if ( m_pSession == nullptr )
402 {
403 // Fail: session was not created
404 ucbhelper::cancelCommandExecution(
405 ucb::IOErrorCode_INVALID_DEVICE,
406 generateErrorArguments(m_aURL),
407 xEnv);
408 }
409 else if ( m_pSession->getRepository() == nullptr )
410 {
411 // Fail: no repository or repository is invalid
412 ucbhelper::cancelCommandExecution(
413 ucb::IOErrorCode_INVALID_DEVICE,
414 generateErrorArguments(m_aURL),
415 xEnv,
416 "error accessing a repository");
417 }
418 else
419 {
420 m_pProvider->registerSession(sSessionId, m_aURL.getUsername( ), m_pSession);
421 if (m_aURL.getBindingUrl() == ONEDRIVE_BASE_URL
422 || m_aURL.getBindingUrl() == GDRIVE_BASE_URL)
423 {
424 aAuthProvider.storeRefreshToken(rUsername, rPassword,
425 m_pSession->getRefreshToken());
426 }
427 }
428
429 bIsDone = true;
430 }
431 catch( const libcmis::Exception & e )
432 {
433 if ( e.getType() != "permissionDenied" )
434 {
435 SAL_INFO("ucb.ucp.cmis", "Unexpected libcmis exception: " << e.what());
436 throw;
437 }
438 }
439 }
440 else
441 {
442 // Silently fail as the user cancelled the authentication
443 ucbhelper::cancelCommandExecution(
444 ucb::IOErrorCode_ABORT,
445 uno::Sequence< uno::Any >( 0 ),
446 xEnv );
447 throw uno::RuntimeException( );
448 }
449 }
450 }
451 return m_pSession;
452 }
453
454 libcmis::ObjectTypePtr const & Content::getObjectType( const uno::Reference< ucb::XCommandEnvironment >& xEnv )
455 {
456 if ( nullptr == m_pObjectType.get( ) && m_bTransient )
457 {
458 std::string typeId = m_bIsFolder ? "cmis:folder" : "cmis:document";
459 // The type to create needs to be fetched from the possible children types
460 // defined in the parent folder. Then, we'll pick up the first one we find matching
461 // cmis:folder or cmis:document (depending what we need to create).
462 // The easy case will work in most cases, but not on some servers (like Lotus Live)
463 libcmis::Folder* pParent = nullptr;
464 bool bTypeRestricted = false;
465 try
466 {
467 pParent = dynamic_cast< libcmis::Folder* >( getObject( xEnv ).get( ) );
468 }
469 catch ( const libcmis::Exception& )
470 {
471 }
472
473 if ( pParent )
474 {
475 std::map< std::string, libcmis::PropertyPtr >& aProperties = pParent->getProperties( );
476 std::map< std::string, libcmis::PropertyPtr >::iterator it = aProperties.find( "cmis:allowedChildObjectTypeIds" );
477 if ( it != aProperties.end( ) )
478 {
479 libcmis::PropertyPtr pProperty = it->second;
480 if ( pProperty )
481 {
482 std::vector< std::string > typesIds = pProperty->getStrings( );
483 for ( const auto& rType : typesIds )
484 {
485 bTypeRestricted = true;
486 libcmis::ObjectTypePtr type = getSession( xEnv )->getType( rType );
487
488 // FIXME Improve performances by adding getBaseTypeId( ) method to libcmis
489 if ( type->getBaseType( )->getId( ) == typeId )
490 {
491 m_pObjectType = type;
492 break;
493 }
494 }
495 }
496 }
497 }
498
499 if ( !bTypeRestricted )
500 m_pObjectType = getSession( xEnv )->getType( typeId );
501 }
502 return m_pObjectType;
503 }
504
505
506 libcmis::ObjectPtr const & Content::getObject( const uno::Reference< ucb::XCommandEnvironment >& xEnv )
507 {
508 // can't get the session for some reason
509 // the recent file opening at start up is an example.
510 try
511 {
512 if ( !getSession( xEnv ) )
513 return m_pObject;
514 }
515 catch ( uno::RuntimeException& )
516 {
517 return m_pObject;
518 }
519 if ( !m_pObject.get() )
520 {
521 if ( !m_sObjectId.isEmpty( ) )
522 {
523 try
524 {
525 m_pObject = getSession( xEnv )->getObject( OUSTR_TO_STDSTR( m_sObjectId ) );
526 }
527 catch ( const libcmis::Exception& )
528 {
529 SAL_INFO( "ucb.ucp.cmis", "object: " << OUSTR_TO_STDSTR(m_sObjectId));
530 throw libcmis::Exception( "Object not found" );
531 }
532 }
533 else if (!(m_sObjectPath.isEmpty() || m_sObjectPath == "/"))
534 {
535 try
536 {
537 m_pObject = getSession( xEnv )->getObjectByPath( OUSTR_TO_STDSTR( m_sObjectPath ) );
538 }
539 catch ( const libcmis::Exception& )
540 {
541 // In some cases, getting the object from the path doesn't work,
542 // but getting the parent from its path and the get the child in the list is OK.
543 // It's weird, but needed to handle case where the path isn't the folders/files
544 // names separated by '/' (as in Lotus Live)
545 INetURLObject aParentUrl( m_sURL );
546 std::string sName = OUSTR_TO_STDSTR( aParentUrl.getName( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset ) );
547 aParentUrl.removeSegment( );
548 OUString sParentUrl = aParentUrl.GetMainURL( INetURLObject::DecodeMechanism::NONE );
549 // Avoid infinite recursion if sParentUrl == m_sURL
550 if (sParentUrl != m_sURL)
551 {
552 rtl::Reference<Content> xParent(new Content(m_xContext, m_pProvider, new ucbhelper::ContentIdentifier(sParentUrl)));
553 libcmis::FolderPtr pParentFolder = boost::dynamic_pointer_cast< libcmis::Folder >(xParent->getObject(xEnv));
554 if (pParentFolder)
555 {
556 std::vector< libcmis::ObjectPtr > children = pParentFolder->getChildren();
557 auto it = std::find_if(children.begin(), children.end(),
558 [&sName](const libcmis::ObjectPtr& rChild) { return rChild->getName() == sName; });
559 if (it != children.end())
560 m_pObject = *it;
561 }
562 }
563
564 if ( !m_pObject )
565 throw libcmis::Exception( "Object not found" );
566 }
567 }
568 else
569 {
570 m_pObject = getSession( xEnv )->getRootFolder( );
571 m_sObjectPath = "/";
572 m_sObjectId = OUString( );
573 }
574 }
575
576 return m_pObject;
577 }
578
579 bool Content::isFolder(const uno::Reference< ucb::XCommandEnvironment >& xEnv )
580 {
581 bool bIsFolder = false;
582 try
583 {
584 libcmis::ObjectPtr obj = getObject( xEnv );
585 if ( obj )
586 bIsFolder = obj->getBaseType( ) == "cmis:folder";
587 }
588 catch ( const libcmis::Exception& e )
589 {
590 SAL_INFO( "ucb.ucp.cmis", "Unexpected libcmis exception: " << e.what( ) );
591
592 ucbhelper::cancelCommandExecution(
593 ucb::IOErrorCode_GENERAL,
594 uno::Sequence< uno::Any >( 0 ),
595 xEnv,
596 OUString::createFromAscii( e.what( ) ) );
597
598 }
599 return bIsFolder;
600 }
601
602 uno::Any Content::getBadArgExcept()
603 {
604 return uno::Any( lang::IllegalArgumentException(
605 "Wrong argument type!",
606 static_cast< cppu::OWeakObject * >( this ), -1) );
607 }
608
609 libcmis::ObjectPtr Content::updateProperties(
610 const uno::Any& iCmisProps,
611 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
612 {
613 // Convert iCmisProps to Cmis Properties;
614 uno::Sequence< document::CmisProperty > aPropsSeq;
615 iCmisProps >>= aPropsSeq;
616 std::map< std::string, libcmis::PropertyPtr > aProperties;
617
618 for ( const auto& rProp : std::as_const(aPropsSeq) )
619 {
620 std::string id = OUSTR_TO_STDSTR( rProp.Id );
621 libcmis::PropertyPtr prop = lcl_unoToCmisProperty( rProp );
622 aProperties.insert( std::pair<std::string, libcmis::PropertyPtr>( id, prop ) );
623 }
624 libcmis::ObjectPtr updateObj;
625 try
626 {
627 updateObj = getObject( xEnv )->updateProperties( aProperties );
628 }
629 catch ( const libcmis::Exception& e )
630 {
631 SAL_INFO( "ucb.ucp.cmis", "Unexpected libcmis exception: "<< e.what( ) );
632 }
633
634 return updateObj;
635 }
636
637 uno::Reference< sdbc::XRow > Content::getPropertyValues(
638 const uno::Sequence< beans::Property >& rProperties,
639 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
640 {
641 rtl::Reference< ::ucbhelper::PropertyValueSet > xRow = new ::ucbhelper::PropertyValueSet( m_xContext );
642
643 for( const beans::Property& rProp : rProperties )
644 {
645 try
646 {
647 if ( rProp.Name == "IsDocument" )
648 {
649 try
650 {
651 libcmis::ObjectPtr obj = getObject( xEnv );
652 if ( obj )
653 xRow->appendBoolean( rProp, obj->getBaseType( ) == "cmis:document" );
654 }
655 catch ( const libcmis::Exception& )
656 {
657 if ( m_pObjectType.get( ) )
658 xRow->appendBoolean( rProp, getObjectType( xEnv )->getBaseType()->getId( ) == "cmis:document" );
659 else
660 xRow->appendVoid( rProp );
661 }
662 }
663 else if ( rProp.Name == "IsFolder" )
664 {
665 try
666 {
667 libcmis::ObjectPtr obj = getObject( xEnv );
668 if ( obj )
669 xRow->appendBoolean( rProp, obj->getBaseType( ) == "cmis:folder" );
670 else
671 xRow->appendBoolean( rProp, false );
672 }
673 catch ( const libcmis::Exception& )
674 {
675 if ( m_pObjectType.get( ) )
676 xRow->appendBoolean( rProp, getObjectType( xEnv )->getBaseType()->getId( ) == "cmis:folder" );
677 else
678 xRow->appendVoid( rProp );
679 }
680 }
681 else if ( rProp.Name == "Title" )
682 {
683 OUString sTitle;
684 try
685 {
686 sTitle = STD_TO_OUSTR( getObject( xEnv )->getName() );
687 }
688 catch ( const libcmis::Exception& )
689 {
690 if ( !m_pObjectProps.empty() )
691 {
692 std::map< std::string, libcmis::PropertyPtr >::iterator it = m_pObjectProps.find( "cmis:name" );
693 if ( it != m_pObjectProps.end( ) )
694 {
695 std::vector< std::string > values = it->second->getStrings( );
696 if ( !values.empty() )
697 sTitle = STD_TO_OUSTR( values.front( ) );
698 }
699 }
700 }
701
702 // Nothing worked... get it from the path
703 if ( sTitle.isEmpty( ) )
704 {
705 OUString sPath = m_sObjectPath;
706
707 // Get rid of the trailing slash problem
708 if ( sPath.endsWith("/") )
709 sPath = sPath.copy( 0, sPath.getLength() - 1 );
710
711 // Get the last segment
712 sal_Int32 nPos = sPath.lastIndexOf( '/' );
713 if ( nPos >= 0 )
714 sTitle = sPath.copy( nPos + 1 );
715 }
716
717 if ( !sTitle.isEmpty( ) )
718 xRow->appendString( rProp, sTitle );
719 else
720 xRow->appendVoid( rProp );
721 }
722 else if ( rProp.Name == "ObjectId" )
723 {
724 OUString sId;
725 try
726 {
727 sId = STD_TO_OUSTR( getObject( xEnv )->getId() );
728 }
729 catch ( const libcmis::Exception& )
730 {
731 if ( !m_pObjectProps.empty() )
732 {
733 std::map< std::string, libcmis::PropertyPtr >::iterator it = m_pObjectProps.find( "cmis:objectId" );
734 if ( it != m_pObjectProps.end( ) )
735 {
736 std::vector< std::string > values = it->second->getStrings( );
737 if ( !values.empty() )
738 sId = STD_TO_OUSTR( values.front( ) );
739 }
740 }
741 }
742
743 if ( !sId.isEmpty( ) )
744 xRow->appendString( rProp, sId );
745 else
746 xRow->appendVoid( rProp );
747 }
748 else if ( rProp.Name == "TitleOnServer" )
749 {
750 xRow->appendString( rProp, m_sObjectPath);
751 }
752 else if ( rProp.Name == "IsReadOnly" )
753 {
754 boost::shared_ptr< libcmis::AllowableActions > allowableActions = getObject( xEnv )->getAllowableActions( );
755 bool bReadOnly = false;
756 if ( !allowableActions->isAllowed( libcmis::ObjectAction::SetContentStream ) &&
757 !allowableActions->isAllowed( libcmis::ObjectAction::CheckIn ) )
758 bReadOnly = true;
759
760 xRow->appendBoolean( rProp, bReadOnly );
761 }
762 else if ( rProp.Name == "DateCreated" )
763 {
764 util::DateTime aTime = lcl_boostToUnoTime( getObject( xEnv )->getCreationDate( ) );
765 xRow->appendTimestamp( rProp, aTime );
766 }
767 else if ( rProp.Name == "DateModified" )
768 {
769 util::DateTime aTime = lcl_boostToUnoTime( getObject( xEnv )->getLastModificationDate( ) );
770 xRow->appendTimestamp( rProp, aTime );
771 }
772 else if ( rProp.Name == "Size" )
773 {
774 try
775 {
776 libcmis::Document* document = dynamic_cast< libcmis::Document* >( getObject( xEnv ).get( ) );
777 if ( nullptr != document )
778 xRow->appendLong( rProp, document->getContentLength() );
779 else
780 xRow->appendVoid( rProp );
781 }
782 catch ( const libcmis::Exception& )
783 {
784 xRow->appendVoid( rProp );
785 }
786 }
787 else if ( rProp.Name == "CreatableContentsInfo" )
788 {
789 xRow->appendObject( rProp, uno::Any( queryCreatableContentsInfo( xEnv ) ) );
790 }
791 else if ( rProp.Name == "MediaType" )
792 {
793 try
794 {
795 libcmis::Document* document = dynamic_cast< libcmis::Document* >( getObject( xEnv ).get( ) );
796 if ( nullptr != document )
797 xRow->appendString( rProp, STD_TO_OUSTR( document->getContentType() ) );
798 else
799 xRow->appendVoid( rProp );
800 }
801 catch ( const libcmis::Exception& )
802 {
803 xRow->appendVoid( rProp );
804 }
805 }
806 else if ( rProp.Name == "IsVolume" )
807 {
808 xRow->appendBoolean( rProp, false );
809 }
810 else if ( rProp.Name == "IsRemote" )
811 {
812 xRow->appendBoolean( rProp, false );
813 }
814 else if ( rProp.Name == "IsRemoveable" )
815 {
816 xRow->appendBoolean( rProp, false );
817 }
818 else if ( rProp.Name == "IsFloppy" )
819 {
820 xRow->appendBoolean( rProp, false );
821 }
822 else if ( rProp.Name == "IsCompactDisc" )
823 {
824 xRow->appendBoolean( rProp, false );
825 }
826 else if ( rProp.Name == "IsHidden" )
827 {
828 xRow->appendBoolean( rProp, false );
829 }
830 else if ( rProp.Name == "TargetURL" )
831 {
832 xRow->appendString( rProp, "" );
833 }
834 else if ( rProp.Name == "BaseURI" )
835 {
836 xRow->appendString( rProp, m_aURL.getBindingUrl( ) );
837 }
838 else if ( rProp.Name == "CmisProperties" )
839 {
840 try
841 {
842 libcmis::ObjectPtr object = getObject( xEnv );
843 std::map< std::string, libcmis::PropertyPtr >& aProperties = object->getProperties( );
844 uno::Sequence< document::CmisProperty > aCmisProperties( aProperties.size( ) );
845 document::CmisProperty* pCmisProps = aCmisProperties.getArray( );
846 sal_Int32 i = 0;
847 for ( const auto& [sId, rProperty] : aProperties )
848 {
849 auto sDisplayName = rProperty->getPropertyType()->getDisplayName( );
850 bool bUpdatable = rProperty->getPropertyType()->isUpdatable( );
851 bool bRequired = rProperty->getPropertyType()->isRequired( );
852 bool bMultiValued = rProperty->getPropertyType()->isMultiValued();
853 bool bOpenChoice = rProperty->getPropertyType()->isOpenChoice();
854
855 pCmisProps[i].Id = STD_TO_OUSTR( sId );
856 pCmisProps[i].Name = STD_TO_OUSTR( sDisplayName );
857 pCmisProps[i].Updatable = bUpdatable;
858 pCmisProps[i].Required = bRequired;
859 pCmisProps[i].MultiValued = bMultiValued;
860 pCmisProps[i].OpenChoice = bOpenChoice;
861 pCmisProps[i].Value = lcl_cmisPropertyToUno( rProperty );
862 switch ( rProperty->getPropertyType( )->getType( ) )
863 {
864 default:
865 case libcmis::PropertyType::String:
866 pCmisProps[i].Type = CMIS_TYPE_STRING;
867 break;
868 case libcmis::PropertyType::Integer:
869 pCmisProps[i].Type = CMIS_TYPE_INTEGER;
870 break;
871 case libcmis::PropertyType::Decimal:
872 pCmisProps[i].Type = CMIS_TYPE_DECIMAL;
873 break;
874 case libcmis::PropertyType::Bool:
875 pCmisProps[i].Type = CMIS_TYPE_BOOL;
876 break;
877 case libcmis::PropertyType::DateTime:
878 pCmisProps[i].Type = CMIS_TYPE_DATETIME;
879 break;
880 }
881 ++i;
882 }
883 xRow->appendObject( rProp.Name, uno::Any( aCmisProperties ) );
884 }
885 catch ( const libcmis::Exception& )
886 {
887 xRow->appendVoid( rProp );
888 }
889 }
890 else if ( rProp.Name == "IsVersionable" )
891 {
892 try
893 {
894 libcmis::ObjectPtr object = getObject( xEnv );
895 bool bIsVersionable = object->getTypeDescription( )->isVersionable( );
896 xRow->appendBoolean( rProp, bIsVersionable );
897 }
898 catch ( const libcmis::Exception& )
899 {
900 xRow->appendVoid( rProp );
901 }
902 }
903 else if ( rProp.Name == "CanCheckOut" )
904 {
905 try
906 {
907 libcmis::ObjectPtr pObject = getObject( xEnv );
908 libcmis::AllowableActionsPtr aAllowables = pObject->getAllowableActions( );
909 bool bAllowed = false;
910 if ( aAllowables )
911 {
912 bAllowed = aAllowables->isAllowed( libcmis::ObjectAction::CheckOut );
913 }
914 xRow->appendBoolean( rProp, bAllowed );
915 }
916 catch ( const libcmis::Exception& )
917 {
918 xRow->appendVoid( rProp );
919 }
920 }
921 else if ( rProp.Name == "CanCancelCheckOut" )
922 {
923 try
924 {
925 libcmis::ObjectPtr pObject = getObject( xEnv );
926 libcmis::AllowableActionsPtr aAllowables = pObject->getAllowableActions( );
927 bool bAllowed = false;
928 if ( aAllowables )
929 {
930 bAllowed = aAllowables->isAllowed( libcmis::ObjectAction::CancelCheckOut );
931 }
932 xRow->appendBoolean( rProp, bAllowed );
933 }
934 catch ( const libcmis::Exception& )
935 {
936 xRow->appendVoid( rProp );
937 }
938 }
939 else if ( rProp.Name == "CanCheckIn" )
940 {
941 try
942 {
943 libcmis::ObjectPtr pObject = getObject( xEnv );
944 libcmis::AllowableActionsPtr aAllowables = pObject->getAllowableActions( );
945 bool bAllowed = false;
946 if ( aAllowables )
947 {
948 bAllowed = aAllowables->isAllowed( libcmis::ObjectAction::CheckIn );
949 }
950 xRow->appendBoolean( rProp, bAllowed );
951 }
952 catch ( const libcmis::Exception& )
953 {
954 xRow->appendVoid( rProp );
955 }
956 }
957 else
958 SAL_INFO( "ucb.ucp.cmis", "Looking for unsupported property " << rProp.Name );
959 }
960 catch (const libcmis::Exception&)
961 {
962 xRow->appendVoid( rProp );
963 }
964 }
965
966 return xRow;
967 }
968
969 uno::Any Content::open(const ucb::OpenCommandArgument2 & rOpenCommand,
970 const uno::Reference< ucb::XCommandEnvironment > & xEnv )
971 {
972 bool bIsFolder = isFolder( xEnv );
973
974 // Handle the case of the non-existing file
975 if ( !getObject( xEnv ) )
976 {
977 uno::Sequence< uno::Any > aArgs{ uno::Any(m_xIdentifier->getContentIdentifier()) };
978 uno::Any aErr(
979 ucb::InteractiveAugmentedIOException(OUString(), static_cast< cppu::OWeakObject * >( this ),
980 task::InteractionClassification_ERROR,
981 bIsFolder ? ucb::IOErrorCode_NOT_EXISTING_PATH : ucb::IOErrorCode_NOT_EXISTING, aArgs)
982 );
983
984 ucbhelper::cancelCommandExecution(aErr, xEnv);
985 }
986
987 uno::Any aRet;
988
989 bool bOpenFolder = (
990 ( rOpenCommand.Mode == ucb::OpenMode::ALL ) ||
991 ( rOpenCommand.Mode == ucb::OpenMode::FOLDERS ) ||
992 ( rOpenCommand.Mode == ucb::OpenMode::DOCUMENTS )
993 );
994
995 if ( bOpenFolder && bIsFolder )
996 {
997 uno::Reference< ucb::XDynamicResultSet > xSet
998 = new DynamicResultSet(m_xContext, this, rOpenCommand, xEnv );
999 aRet <<= xSet;
1000 }
1001 else if ( rOpenCommand.Sink.is() )
1002 {
1003 if (
1004 ( rOpenCommand.Mode == ucb::OpenMode::DOCUMENT_SHARE_DENY_NONE ) ||
1005 ( rOpenCommand.Mode == ucb::OpenMode::DOCUMENT_SHARE_DENY_WRITE )
1006 )
1007 {
1008 ucbhelper::cancelCommandExecution(
1009 uno::Any ( ucb::UnsupportedOpenModeException
1010 ( OUString(), static_cast< cppu::OWeakObject * >( this ),
1011 sal_Int16( rOpenCommand.Mode ) ) ),
1012 xEnv );
1013 }
1014
1015 if ( !feedSink( rOpenCommand.Sink, xEnv ) )
1016 {
1017 // Note: rOpenCommand.Sink may contain an XStream
1018 // implementation. Support for this type of
1019 // sink is optional...
1020 SAL_INFO( "ucb.ucp.cmis", "Failed to copy data to sink" );
1021
1022 ucbhelper::cancelCommandExecution(
1023 uno::Any (ucb::UnsupportedDataSinkException
1024 ( OUString(), static_cast< cppu::OWeakObject * >( this ),
1025 rOpenCommand.Sink ) ),
1026 xEnv );
1027 }
1028 }
1029 else
1030 SAL_INFO( "ucb.ucp.cmis", "Open falling through ..." );
1031
1032 return aRet;
1033 }
1034
1035 OUString Content::checkIn( const ucb::CheckinArgument& rArg,
1036 const uno::Reference< ucb::XCommandEnvironment > & xEnv )
1037 {
1038 ucbhelper::Content aSourceContent( rArg.SourceURL, xEnv, comphelper::getProcessComponentContext( ) );
1039 uno::Reference< io::XInputStream > xIn = aSourceContent.openStream( );
1040
1041 libcmis::ObjectPtr object;
1042 try
1043 {
1044 object = getObject( xEnv );
1045 }
1046 catch ( const libcmis::Exception& e )
1047 {
1048 SAL_INFO( "ucb.ucp.cmis", "Unexpected libcmis exception: " << e.what( ) );
1049 ucbhelper::cancelCommandExecution(
1050 ucb::IOErrorCode_GENERAL,
1051 uno::Sequence< uno::Any >( 0 ),
1052 xEnv,
1053 OUString::createFromAscii( e.what() ) );
1054 }
1055
1056 libcmis::Document* pPwc = dynamic_cast< libcmis::Document* >( object.get( ) );
1057 if ( !pPwc )
1058 {
1059 ucbhelper::cancelCommandExecution(
1060 ucb::IOErrorCode_GENERAL,
1061 uno::Sequence< uno::Any >( 0 ),
1062 xEnv,
1063 "Checkin only supported by documents" );
1064 }
1065
1066 boost::shared_ptr< std::ostream > pOut( new std::ostringstream ( std::ios_base::binary | std::ios_base::in | std::ios_base::out ) );
1067 uno::Reference < io::XOutputStream > xOutput = new StdOutputStream( pOut );
1068 copyData( xIn, xOutput );
1069
1070 std::map< std::string, libcmis::PropertyPtr > newProperties;
1071 libcmis::DocumentPtr pDoc;
1072
1073 try
1074 {
1075 pDoc = pPwc->checkIn( rArg.MajorVersion, OUSTR_TO_STDSTR( rArg.VersionComment ), newProperties,
1076 pOut, OUSTR_TO_STDSTR( rArg.MimeType ), OUSTR_TO_STDSTR( rArg.NewTitle ) );
1077 }
1078 catch ( const libcmis::Exception& e )
1079 {
1080 SAL_INFO( "ucb.ucp.cmis", "Unexpected libcmis exception: " << e.what( ) );
1081 ucbhelper::cancelCommandExecution(
1082 ucb::IOErrorCode_GENERAL,
1083 uno::Sequence< uno::Any >( 0 ),
1084 xEnv,
1085 OUString::createFromAscii( e.what() ) );
1086 }
1087
1088 // Get the URL and send it back as a result
1089 URL aCmisUrl( m_sURL );
1090 std::vector< std::string > aPaths = pDoc->getPaths( );
1091 if ( !aPaths.empty() )
1092 {
1093 auto sPath = aPaths.front( );
1094 aCmisUrl.setObjectPath( STD_TO_OUSTR( sPath ) );
1095 }
1096 else
1097 {
1098 // We may have unfiled document depending on the server, those
1099 // won't have any path, use their ID instead
1100 auto sId = pDoc->getId( );
1101 aCmisUrl.setObjectId( STD_TO_OUSTR( sId ) );
1102 }
1103 return aCmisUrl.asString( );
1104 }
1105
1106 OUString Content::checkOut( const uno::Reference< ucb::XCommandEnvironment > & xEnv )
1107 {
1108 OUString aRet;
1109 try
1110 {
1111 // Checkout the document if possible
1112 libcmis::DocumentPtr pDoc = boost::dynamic_pointer_cast< libcmis::Document >( getObject( xEnv ) );
1113 if ( pDoc.get( ) == nullptr )
1114 {
1115 ucbhelper::cancelCommandExecution(
1116 ucb::IOErrorCode_GENERAL,
1117 uno::Sequence< uno::Any >( 0 ),
1118 xEnv,
1119 "Checkout only supported by documents" );
1120 }
1121 libcmis::DocumentPtr pPwc = pDoc->checkOut( );
1122
1123 // Compute the URL of the Private Working Copy (PWC)
1124 URL aCmisUrl( m_sURL );
1125 std::vector< std::string > aPaths = pPwc->getPaths( );
1126 if ( !aPaths.empty() )
1127 {
1128 auto sPath = aPaths.front( );
1129 aCmisUrl.setObjectPath( STD_TO_OUSTR( sPath ) );
1130 }
1131 else
1132 {
1133 // We may have unfiled PWC depending on the server, those
1134 // won't have any path, use their ID instead
1135 auto sId = pPwc->getId( );
1136 aCmisUrl.setObjectId( STD_TO_OUSTR( sId ) );
1137 }
1138 aRet = aCmisUrl.asString( );
1139 }
1140 catch ( const libcmis::Exception& e )
1141 {
1142 SAL_INFO( "ucb.ucp.cmis", "Unexpected libcmis exception: " << e.what( ) );
1143 ucbhelper::cancelCommandExecution(
1144 ucb::IOErrorCode_GENERAL,
1145 uno::Sequence< uno::Any >( 0 ),
1146 xEnv,
1147 o3tl::runtimeToOUString(e.what()));
1148 }
1149 return aRet;
1150 }
1151
1152 OUString Content::cancelCheckOut( const uno::Reference< ucb::XCommandEnvironment > & xEnv )
1153 {
1154 OUString aRet;
1155 try
1156 {
1157 libcmis::DocumentPtr pPwc = boost::dynamic_pointer_cast< libcmis::Document >( getObject( xEnv ) );
1158 if ( pPwc.get( ) == nullptr )
1159 {
1160 ucbhelper::cancelCommandExecution(
1161 ucb::IOErrorCode_GENERAL,
1162 uno::Sequence< uno::Any >( 0 ),
1163 xEnv,
1164 "CancelCheckout only supported by documents" );
1165 }
1166 pPwc->cancelCheckout( );
1167
1168 // Get the Original document (latest version)
1169 std::vector< libcmis::DocumentPtr > aVersions = pPwc->getAllVersions( );
1170 for ( const auto& rVersion : aVersions )
1171 {
1172 libcmis::DocumentPtr pVersion = rVersion;
1173 std::map< std::string, libcmis::PropertyPtr > aProps = pVersion->getProperties( );
1174 bool bIsLatestVersion = false;
1175 std::map< std::string, libcmis::PropertyPtr >::iterator propIt = aProps.find( std::string( "cmis:isLatestVersion" ) );
1176 if ( propIt != aProps.end( ) && !propIt->second->getBools( ).empty( ) )
1177 {
1178 bIsLatestVersion = propIt->second->getBools( ).front( );
1179 }
1180
1181 if ( bIsLatestVersion )
1182 {
1183 // Compute the URL of the Document
1184 URL aCmisUrl( m_sURL );
1185 std::vector< std::string > aPaths = pVersion->getPaths( );
1186 if ( !aPaths.empty() )
1187 {
1188 auto sPath = aPaths.front( );
1189 aCmisUrl.setObjectPath( STD_TO_OUSTR( sPath ) );
1190 }
1191 else
1192 {
1193 // We may have unfiled doc depending on the server, those
1194 // won't have any path, use their ID instead
1195 auto sId = pVersion->getId( );
1196 aCmisUrl.setObjectId( STD_TO_OUSTR( sId ) );
1197 }
1198 aRet = aCmisUrl.asString( );
1199 break;
1200 }
1201 }
1202 }
1203 catch ( const libcmis::Exception& e )
1204 {
1205 SAL_INFO( "ucb.ucp.cmis", "Unexpected libcmis exception: " << e.what( ) );
1206 ucbhelper::cancelCommandExecution(
1207 ucb::IOErrorCode_GENERAL,
1208 uno::Sequence< uno::Any >( 0 ),
1209 xEnv,
1210 o3tl::runtimeToOUString(e.what()));
1211 }
1212 return aRet;
1213 }
1214
1215 uno::Sequence< document::CmisVersion> Content::getAllVersions( const uno::Reference< ucb::XCommandEnvironment > & xEnv )
1216 {
1217 try
1218 {
1219 // get the document
1220 libcmis::DocumentPtr pDoc = boost::dynamic_pointer_cast< libcmis::Document >( getObject( xEnv ) );
1221 if ( pDoc.get( ) == nullptr )
1222 {
1223 ucbhelper::cancelCommandExecution(
1224 ucb::IOErrorCode_GENERAL,
1225 uno::Sequence< uno::Any >( 0 ),
1226 xEnv,
1227 "Can not get the document" );
1228 }
1229 std::vector< libcmis::DocumentPtr > aCmisVersions = pDoc->getAllVersions( );
1230 uno::Sequence< document::CmisVersion > aVersions( aCmisVersions.size( ) );
1231 auto aVersionsRange = asNonConstRange(aVersions);
1232 int i = 0;
1233 for ( const auto& rVersion : aCmisVersions )
1234 {
1235 libcmis::DocumentPtr pVersion = rVersion;
1236 aVersionsRange[i].Id = STD_TO_OUSTR( pVersion->getId( ) );
1237 aVersionsRange[i].Author = STD_TO_OUSTR( pVersion->getCreatedBy( ) );
1238 aVersionsRange[i].TimeStamp = lcl_boostToUnoTime( pVersion->getLastModificationDate( ) );
1239 aVersionsRange[i].Comment = STD_TO_OUSTR( pVersion->getStringProperty("cmis:checkinComment") );
1240 ++i;
1241 }
1242 return aVersions;
1243 }
1244 catch ( const libcmis::Exception& e )
1245 {
1246 SAL_INFO( "ucb.ucp.cmis", "Unexpected libcmis exception: " << e.what( ) );
1247 ucbhelper::cancelCommandExecution(
1248 ucb::IOErrorCode_GENERAL,
1249 uno::Sequence< uno::Any >( 0 ),
1250 xEnv,
1251 o3tl::runtimeToOUString(e.what()));
1252 }
1253 return uno::Sequence< document::CmisVersion > ( );
1254 }
1255
1256 void Content::transfer( const ucb::TransferInfo& rTransferInfo,
1257 const uno::Reference< ucb::XCommandEnvironment > & xEnv )
1258 {
1259 // If the source isn't on the same CMIS repository, then simply copy
1260 INetURLObject aSourceUrl( rTransferInfo.SourceURL );
1261 if ( aSourceUrl.GetProtocol() != INetProtocol::Cmis )
1262 {
1263 OUString sSrcBindingUrl = URL( rTransferInfo.SourceURL ).getBindingUrl( );
1264 if ( sSrcBindingUrl != m_aURL.getBindingUrl( ) )
1265 {
1266 ucbhelper::cancelCommandExecution(
1267 uno::Any(
1268 ucb::InteractiveBadTransferURLException(
1269 "Unsupported URL scheme!",
1270 static_cast< cppu::OWeakObject * >( this ) ) ),
1271 xEnv );
1272 }
1273 }
1274
1275 SAL_INFO( "ucb.ucp.cmis", "TODO - Content::transfer()" );
1276 }
1277
1278 void Content::insert( const uno::Reference< io::XInputStream > & xInputStream,
1279 bool bReplaceExisting, std::u16string_view rMimeType,
1280 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
1281 {
1282 if ( !xInputStream.is() )
1283 {
1284 ucbhelper::cancelCommandExecution( uno::Any
1285 ( ucb::MissingInputStreamException
1286 ( OUString(), static_cast< cppu::OWeakObject * >( this ) ) ),
1287 xEnv );
1288 }
1289
1290 // For transient content, the URL is the one of the parent
1291 if ( !m_bTransient )
1292 return;
1293
1294 OUString sNewPath;
1295
1296 // Try to get the object from the server if there is any
1297 libcmis::FolderPtr pFolder;
1298 try
1299 {
1300 pFolder = boost::dynamic_pointer_cast< libcmis::Folder >( getObject( xEnv ) );
1301 }
1302 catch ( const libcmis::Exception& )
1303 {
1304 }
1305
1306 if ( pFolder == nullptr )
1307 return;
1308
1309 libcmis::ObjectPtr object;
1310 std::map< std::string, libcmis::PropertyPtr >::iterator it = m_pObjectProps.find( "cmis:name" );
1311 if ( it == m_pObjectProps.end( ) )
1312 {
1313 ucbhelper::cancelCommandExecution( uno::Any
1314 ( uno::RuntimeException( "Missing name property",
1315 static_cast< cppu::OWeakObject * >( this ) ) ),
1316 xEnv );
1317 }
1318 auto newName = it->second->getStrings( ).front( );
1319 auto newPath = OUSTR_TO_STDSTR( m_sObjectPath );
1320 if ( !newPath.empty( ) && newPath[ newPath.size( ) - 1 ] != '/' )
1321 newPath += "/";
1322 newPath += newName;
1323 try
1324 {
1325 if ( !m_sObjectId.isEmpty( ) )
1326 object = getSession( xEnv )->getObject( OUSTR_TO_STDSTR( m_sObjectId) );
1327 else
1328 object = getSession( xEnv )->getObjectByPath( newPath );
1329 sNewPath = STD_TO_OUSTR( newPath );
1330 }
1331 catch ( const libcmis::Exception& )
1332 {
1333 // Nothing matched the path
1334 }
1335
1336 if ( nullptr != object.get( ) )
1337 {
1338 // Are the base type matching?
1339 if ( object->getBaseType( ) != m_pObjectType->getBaseType( )->getId() )
1340 {
1341 ucbhelper::cancelCommandExecution( uno::Any
1342 ( uno::RuntimeException( "Can't change a folder into a document and vice-versa.",
1343 static_cast< cppu::OWeakObject * >( this ) ) ),
1344 xEnv );
1345 }
1346
1347 // Update the existing object if it's a document
1348 libcmis::Document* document = dynamic_cast< libcmis::Document* >( object.get( ) );
1349 if ( nullptr != document )
1350 {
1351 boost::shared_ptr< std::ostream > pOut( new std::ostringstream ( std::ios_base::binary | std::ios_base::in | std::ios_base::out ) );
1352 uno::Reference < io::XOutputStream > xOutput = new StdOutputStream( pOut );
1353 copyData( xInputStream, xOutput );
1354 try
1355 {
1356 document->setContentStream( pOut, OUSTR_TO_STDSTR( rMimeType ), std::string( ), bReplaceExisting );
1357 }
1358 catch ( const libcmis::Exception& )
1359 {
1360 ucbhelper::cancelCommandExecution( uno::Any
1361 ( uno::RuntimeException( "Error when setting document content",
1362 static_cast< cppu::OWeakObject * >( this ) ) ),
1363 xEnv );
1364 }
1365 }
1366 }
1367 else
1368 {
1369 // We need to create a brand new object... either folder or document
1370 bool bIsFolder = getObjectType( xEnv )->getBaseType( )->getId( ) == "cmis:folder";
1371 setCmisProperty( "cmis:objectTypeId", getObjectType( xEnv )->getId( ), xEnv );
1372
1373 if ( bIsFolder )
1374 {
1375 try
1376 {
1377 pFolder->createFolder( m_pObjectProps );
1378 sNewPath = STD_TO_OUSTR( newPath );
1379 }
1380 catch ( const libcmis::Exception& )
1381 {
1382 ucbhelper::cancelCommandExecution( uno::Any
1383 ( uno::RuntimeException( "Error when creating folder",
1384 static_cast< cppu::OWeakObject * >( this ) ) ),
1385 xEnv );
1386 }
1387 }
1388 else
1389 {
1390 boost::shared_ptr< std::ostream > pOut( new std::ostringstream ( std::ios_base::binary | std::ios_base::in | std::ios_base::out ) );
1391 uno::Reference < io::XOutputStream > xOutput = new StdOutputStream( pOut );
1392 copyData( xInputStream, xOutput );
1393 try
1394 {
1395 pFolder->createDocument( m_pObjectProps, pOut, OUSTR_TO_STDSTR( rMimeType ), std::string() );
1396 sNewPath = STD_TO_OUSTR( newPath );
1397 }
1398 catch ( const libcmis::Exception& )
1399 {
1400 ucbhelper::cancelCommandExecution( uno::Any
1401 ( uno::RuntimeException( "Error when creating document",
1402 static_cast< cppu::OWeakObject * >( this ) ) ),
1403 xEnv );
1404 }
1405 }
1406 }
1407
1408 if ( sNewPath.isEmpty( ) && m_sObjectId.isEmpty( ) )
1409 return;
1410
1411 // Update the current content: it's no longer transient
1412 m_sObjectPath = sNewPath;
1413 URL aUrl( m_sURL );
1414 aUrl.setObjectPath( m_sObjectPath );
1415 aUrl.setObjectId( m_sObjectId );
1416 m_sURL = aUrl.asString( );
1417 m_pObject.reset( );
1418 m_pObjectType.reset( );
1419 m_pObjectProps.clear( );
1420 m_bTransient = false;
1421 inserted();
1422 }
1423
1424 const int TRANSFER_BUFFER_SIZE = 65536;
1425
1426 void Content::copyData(
1427 const uno::Reference< io::XInputStream >& xIn,
1428 const uno::Reference< io::XOutputStream >& xOut )
1429 {
1430 uno::Sequence< sal_Int8 > theData( TRANSFER_BUFFER_SIZE );
1431
1432 while ( xIn->readBytes( theData, TRANSFER_BUFFER_SIZE ) > 0 )
1433 xOut->writeBytes( theData );
1434
1435 xOut->closeOutput();
1436 }
1437
1438 uno::Sequence< uno::Any > Content::setPropertyValues(
1439 const uno::Sequence< beans::PropertyValue >& rValues,
1440 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
1441 {
1442 try
1443 {
1444 // Get the already set properties if possible
1445 if ( !m_bTransient && getObject( xEnv ).get( ) )
1446 {
1447 m_pObjectProps.clear( );
1448 m_pObjectType = getObject( xEnv )->getTypeDescription();
1449 }
1450 }
1451 catch ( const libcmis::Exception& e )
1452 {
1453 SAL_INFO( "ucb.ucp.cmis", "Unexpected libcmis exception: " << e.what( ) );
1454 ucbhelper::cancelCommandExecution(
1455 ucb::IOErrorCode_GENERAL,
1456 uno::Sequence< uno::Any >( 0 ),
1457 xEnv,
1458 o3tl::runtimeToOUString(e.what()));
1459 }
1460
1461 sal_Int32 nCount = rValues.getLength();
1462 uno::Sequence< uno::Any > aRet( nCount );
1463 auto aRetRange = asNonConstRange(aRet);
1464 bool bChanged = false;
1465 const beans::PropertyValue* pValues = rValues.getConstArray();
1466 for ( sal_Int32 n = 0; n < nCount; ++n )
1467 {
1468 const beans::PropertyValue& rValue = pValues[ n ];
1469 if ( rValue.Name == "ContentType" ||
1470 rValue.Name == "MediaType" ||
1471 rValue.Name == "IsDocument" ||
1472 rValue.Name == "IsFolder" ||
1473 rValue.Name == "Size" ||
1474 rValue.Name == "CreatableContentsInfo" )
1475 {
1476 lang::IllegalAccessException e ( "Property is read-only!",
1477 static_cast< cppu::OWeakObject* >( this ) );
1478 aRetRange[ n ] <<= e;
1479 }
1480 else if ( rValue.Name == "Title" )
1481 {
1482 OUString aNewTitle;
1483 if (!( rValue.Value >>= aNewTitle ))
1484 {
1485 aRetRange[ n ] <<= beans::IllegalTypeException
1486 ( "Property value has wrong type!",
1487 static_cast< cppu::OWeakObject * >( this ) );
1488 continue;
1489 }
1490
1491 if ( aNewTitle.isEmpty() )
1492 {
1493 aRetRange[ n ] <<= lang::IllegalArgumentException
1494 ( "Empty title not allowed!",
1495 static_cast< cppu::OWeakObject * >( this ), -1 );
1496 continue;
1497
1498 }
1499
1500 setCmisProperty( "cmis:name", OUSTR_TO_STDSTR( aNewTitle ), xEnv );
1501 bChanged = true;
1502 }
1503 else
1504 {
1505 SAL_INFO( "ucb.ucp.cmis", "Couldn't set property: " << rValue.Name );
1506 lang::IllegalAccessException e ( "Property is read-only!",
1507 static_cast< cppu::OWeakObject* >( this ) );
1508 aRetRange[ n ] <<= e;
1509 }
1510 }
1511
1512 try
1513 {
1514 if ( !m_bTransient && bChanged )
1515 {
1516 getObject( xEnv )->updateProperties( m_pObjectProps );
1517 }
1518 }
1519 catch ( const libcmis::Exception& e )
1520 {
1521 SAL_INFO( "ucb.ucp.cmis", "Unexpected libcmis exception: " << e.what( ) );
1522 ucbhelper::cancelCommandExecution(
1523 ucb::IOErrorCode_GENERAL,
1524 uno::Sequence< uno::Any >( 0 ),
1525 xEnv,
1526 o3tl::runtimeToOUString(e.what()));
1527 }
1528
1529 return aRet;
1530 }
1531
1532 bool Content::feedSink( const uno::Reference< uno::XInterface>& xSink,
1533 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
1534 {
1535 if ( !xSink.is() )
1536 return false;
1537
1538 uno::Reference< io::XOutputStream > xOut(xSink, uno::UNO_QUERY );
1539 uno::Reference< io::XActiveDataSink > xDataSink(xSink, uno::UNO_QUERY );
1540 uno::Reference< io::XActiveDataStreamer > xDataStreamer( xSink, uno::UNO_QUERY );
1541
1542 if ( !xOut.is() && !xDataSink.is() && ( !xDataStreamer.is() || !xDataStreamer->getStream().is() ) )
1543 return false;
1544
1545 if ( xDataStreamer.is() && !xOut.is() )
1546 xOut = xDataStreamer->getStream()->getOutputStream();
1547
1548 try
1549 {
1550 libcmis::Document* document = dynamic_cast< libcmis::Document* >( getObject( xEnv ).get() );
1551
1552 if (!document)
1553 return false;
1554
1555 boost::shared_ptr< std::istream > aIn = document->getContentStream( );
1556
1557 uno::Reference< io::XInputStream > xIn = new StdInputStream( aIn );
1558 if( !xIn.is( ) )
1559 return false;
1560
1561 if ( xDataSink.is() )
1562 xDataSink->setInputStream( xIn );
1563 else if ( xOut.is() )
1564 copyData( xIn, xOut );
1565 }
1566 catch ( const libcmis::Exception& e )
1567 {
1568 SAL_INFO( "ucb.ucp.cmis", "Unexpected libcmis exception: " << e.what( ) );
1569 ucbhelper::cancelCommandExecution(
1570 ucb::IOErrorCode_GENERAL,
1571 uno::Sequence< uno::Any >( 0 ),
1572 xEnv,
1573 o3tl::runtimeToOUString(e.what()));
1574 }
1575
1576 return true;
1577 }
1578
1579 uno::Sequence< beans::Property > Content::getProperties(
1580 const uno::Reference< ucb::XCommandEnvironment > & )
1581 {
1582 static const beans::Property aGenericProperties[] =
1583 {
1584 beans::Property( "IsDocument",
1585 -1, cppu::UnoType<bool>::get(),
1586 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
1587 beans::Property( "IsFolder",
1588 -1, cppu::UnoType<bool>::get(),
1589 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
1590 beans::Property( "Title",
1591 -1, cppu::UnoType<OUString>::get(),
1592 beans::PropertyAttribute::BOUND ),
1593 beans::Property( "ObjectId",
1594 -1, cppu::UnoType<OUString>::get(),
1595 beans::PropertyAttribute::BOUND ),
1596 beans::Property( "TitleOnServer",
1597 -1, cppu::UnoType<OUString>::get(),
1598 beans::PropertyAttribute::BOUND ),
1599 beans::Property( "IsReadOnly",
1600 -1, cppu::UnoType<bool>::get(),
1601 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
1602 beans::Property( "DateCreated",
1603 -1, cppu::UnoType<util::DateTime>::get(),
1604 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
1605 beans::Property( "DateModified",
1606 -1, cppu::UnoType<util::DateTime>::get(),
1607 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
1608 beans::Property( "Size",
1609 -1, cppu::UnoType<sal_Int64>::get(),
1610 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
1611 beans::Property( "CreatableContentsInfo",
1612 -1, cppu::UnoType<uno::Sequence< ucb::ContentInfo >>::get(),
1613 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
1614 beans::Property( "MediaType",
1615 -1, cppu::UnoType<OUString>::get(),
1616 beans::PropertyAttribute::BOUND ),
1617 beans::Property( "CmisProperties",
1618 -1, cppu::UnoType<uno::Sequence< document::CmisProperty>>::get(),
1619 beans::PropertyAttribute::BOUND ),
1620 beans::Property( "IsVersionable",
1621 -1, cppu::UnoType<bool>::get(),
1622 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
1623 beans::Property( "CanCheckOut",
1624 -1, cppu::UnoType<bool>::get(),
1625 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
1626 beans::Property( "CanCancelCheckOut",
1627 -1, cppu::UnoType<bool>::get(),
1628 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
1629 beans::Property( "CanCheckIn",
1630 -1, cppu::UnoType<bool>::get(),
1631 beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY ),
1632 };
1633
1634 const int nProps = SAL_N_ELEMENTS(aGenericProperties);
1635 return uno::Sequence< beans::Property > ( aGenericProperties, nProps );
1636 }
1637
1638 uno::Sequence< ucb::CommandInfo > Content::getCommands(
1639 const uno::Reference< ucb::XCommandEnvironment > & xEnv )
1640 {
1641 static const ucb::CommandInfo aCommandInfoTable[] =
1642 {
1643 // Required commands
1644 ucb::CommandInfo
1645 ( "getCommandInfo",
1646 -1, cppu::UnoType<void>::get() ),
1647 ucb::CommandInfo
1648 ( "getPropertySetInfo",
1649 -1, cppu::UnoType<void>::get() ),
1650 ucb::CommandInfo
1651 ( "getPropertyValues",
1652 -1, cppu::UnoType<uno::Sequence< beans::Property >>::get() ),
1653 ucb::CommandInfo
1654 ( "setPropertyValues",
1655 -1, cppu::UnoType<uno::Sequence< beans::PropertyValue >>::get() ),
1656
1657 // Optional standard commands
1658 ucb::CommandInfo
1659 ( "delete",
1660 -1, cppu::UnoType<bool>::get() ),
1661 ucb::CommandInfo
1662 ( "insert",
1663 -1, cppu::UnoType<ucb::InsertCommandArgument2>::get() ),
1664 ucb::CommandInfo
1665 ( "open",
1666 -1, cppu::UnoType<ucb::OpenCommandArgument2>::get() ),
1667
1668 // Mandatory CMIS-only commands
1669 ucb::CommandInfo ( "checkout", -1, cppu::UnoType<void>::get() ),
1670 ucb::CommandInfo ( "cancelCheckout", -1, cppu::UnoType<void>::get() ),
1671 ucb::CommandInfo ( "checkIn", -1,
1672 cppu::UnoType<ucb::TransferInfo>::get() ),
1673 ucb::CommandInfo ( "updateProperties", -1, cppu::UnoType<void>::get() ),
1674 ucb::CommandInfo
1675 ( "getAllVersions",
1676 -1, cppu::UnoType<uno::Sequence< document::CmisVersion >>::get() ),
1677
1678
1679 // Folder Only, omitted if not a folder
1680 ucb::CommandInfo
1681 ( "transfer",
1682 -1, cppu::UnoType<ucb::TransferInfo>::get() ),
1683 ucb::CommandInfo
1684 ( "createNewContent",
1685 -1, cppu::UnoType<ucb::ContentInfo>::get() )
1686 };
1687
1688 const int nProps = SAL_N_ELEMENTS( aCommandInfoTable );
1689 return uno::Sequence< ucb::CommandInfo >(aCommandInfoTable, isFolder( xEnv ) ? nProps : nProps - 2);
1690 }
1691
1692 OUString Content::getParentURL( )
1693 {
1694 SAL_INFO( "ucb.ucp.cmis", "Content::getParentURL()" );
1695 OUString parentUrl = "/";
1696 if ( m_sObjectPath == "/" )
1697 return parentUrl;
1698 else
1699 {
1700 INetURLObject aUrl( m_sURL );
1701 if ( aUrl.getSegmentCount( ) > 0 )
1702 {
1703 URL aCmisUrl( m_sURL );
1704 aUrl.removeSegment( );
1705 aCmisUrl.setObjectPath( aUrl.GetURLPath( INetURLObject::DecodeMechanism::WithCharset ) );
1706 parentUrl = aCmisUrl.asString( );
1707 }
1708 }
1709 return parentUrl;
1710 }
1711
1712 XTYPEPROVIDER_COMMON_IMPL( Content );
1713
1714 void SAL_CALL Content::acquire() noexcept
1715 {
1716 ContentImplHelper::acquire();
1717 }
1718
1719 void SAL_CALL Content::release() noexcept
1720 {
1721 ContentImplHelper::release();
1722 }
1723
1724 uno::Any SAL_CALL Content::queryInterface( const uno::Type & rType )
1725 {
1726 uno::Any aRet = cppu::queryInterface( rType, static_cast< ucb::XContentCreator * >( this ) );
1727 return aRet.hasValue() ? aRet : ContentImplHelper::queryInterface(rType);
1728 }
1729
1730 OUString SAL_CALL Content::getImplementationName()
1731 {
1732 return "com.sun.star.comp.CmisContent";
1733 }
1734
1735 uno::Sequence< OUString > SAL_CALL Content::getSupportedServiceNames()
1736 {
1737 uno::Sequence<OUString> aSNS { "com.sun.star.ucb.CmisContent" };
1738 return aSNS;
1739 }
1740
1741 OUString SAL_CALL Content::getContentType()
1742 {
1743 OUString sRet;
1744 try
1745 {
1746 if (isFolder( uno::Reference< ucb::XCommandEnvironment >() ))
1747 sRet = CMIS_FOLDER_TYPE;
1748 else
1749 sRet = CMIS_FILE_TYPE;
1750 }
1751 catch (const uno::RuntimeException&)
1752 {
1753 throw;
1754 }
1755 catch (const uno::Exception& e)
1756 {
1757 uno::Any a(cppu::getCaughtException());
1758 throw lang::WrappedTargetRuntimeException(
1759 "wrapped Exception " + e.Message,
1760 uno::Reference<uno::XInterface>(), a);
1761 }
1762 return sRet;
1763 }
1764
1765 uno::Any SAL_CALL Content::execute(
1766 const ucb::Command& aCommand,
1767 sal_Int32 /*CommandId*/,
1768 const uno::Reference< ucb::XCommandEnvironment >& xEnv )
1769 {
1770 SAL_INFO( "ucb.ucp.cmis", "Content::execute( ) - " << aCommand.Name );
1771 uno::Any aRet;
1772
1773 if ( aCommand.Name == "getPropertyValues" )
1774 {
1775 uno::Sequence< beans::Property > Properties;
1776 if ( !( aCommand.Argument >>= Properties ) )
1777 ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv );
1778 aRet <<= getPropertyValues( Properties, xEnv );
1779 }
1780 else if ( aCommand.Name == "getPropertySetInfo" )
1781 aRet <<= getPropertySetInfo( xEnv, false );
1782 else if ( aCommand.Name == "getCommandInfo" )
1783 aRet <<= getCommandInfo( xEnv, false );
1784 else if ( aCommand.Name == "open" )
1785 {
1786 ucb::OpenCommandArgument2 aOpenCommand;
1787 if ( !( aCommand.Argument >>= aOpenCommand ) )
1788 ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv );
1789 aRet = open( aOpenCommand, xEnv );
1790 }
1791 else if ( aCommand.Name == "transfer" )
1792 {
1793 ucb::TransferInfo transferArgs;
1794 if ( !( aCommand.Argument >>= transferArgs ) )
1795 ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv );
1796 transfer( transferArgs, xEnv );
1797 }
1798 else if ( aCommand.Name == "setPropertyValues" )
1799 {
1800 uno::Sequence< beans::PropertyValue > aProperties;
1801 if ( !( aCommand.Argument >>= aProperties ) || !aProperties.hasElements() )
1802 ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv );
1803 aRet <<= setPropertyValues( aProperties, xEnv );
1804 }
1805 else if (aCommand.Name == "createNewContent"
1806 && isFolder( xEnv ) )
1807 {
1808 ucb::ContentInfo arg;
1809 if ( !( aCommand.Argument >>= arg ) )
1810 ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv );
1811 aRet <<= createNewContent( arg );
1812 }
1813 else if ( aCommand.Name == "insert" )
1814 {
1815 ucb::InsertCommandArgument2 arg;
1816 if ( !( aCommand.Argument >>= arg ) )
1817 {
1818 ucb::InsertCommandArgument insertArg;
1819 if ( !( aCommand.Argument >>= insertArg ) )
1820 ucbhelper::cancelCommandExecution ( getBadArgExcept (), xEnv );
1821
1822 arg.Data = insertArg.Data;
1823 arg.ReplaceExisting = insertArg.ReplaceExisting;
1824 }
1825 // store the document id
1826 m_sObjectId = arg.DocumentId;
1827 insert( arg.Data, arg.ReplaceExisting, arg.MimeType, xEnv );
1828 }
1829 else if ( aCommand.Name == "delete" )
1830 {
1831 try
1832 {
1833 if ( !isFolder( xEnv ) )
1834 {
1835 getObject( xEnv )->remove( );
1836 }
1837 else
1838 {
1839 libcmis::Folder* folder = dynamic_cast< libcmis::Folder* >( getObject( xEnv ).get() );
1840 if (folder)
1841 folder->removeTree( );
1842 }
1843 }
1844 catch ( const libcmis::Exception& e )
1845 {
1846 SAL_INFO( "ucb.ucp.cmis", "Unexpected libcmis exception: " << e.what( ) );
1847 ucbhelper::cancelCommandExecution(
1848 ucb::IOErrorCode_GENERAL,
1849 uno::Sequence< uno::Any >( 0 ),
1850 xEnv,
1851 o3tl::runtimeToOUString(e.what()));
1852 }
1853 }
1854 else if ( aCommand.Name == "checkout" )
1855 {
1856 aRet <<= checkOut( xEnv );
1857 }
1858 else if ( aCommand.Name == "cancelCheckout" )
1859 {
1860 aRet <<= cancelCheckOut( xEnv );
1861 }
1862 else if ( aCommand.Name == "checkin" )
1863 {
1864 ucb::CheckinArgument aArg;
1865 if ( !( aCommand.Argument >>= aArg ) )
1866 {
1867 ucbhelper::cancelCommandExecution ( getBadArgExcept(), xEnv );
1868 }
1869 aRet <<= checkIn( aArg, xEnv );
1870 }
1871 else if ( aCommand.Name == "getAllVersions" )
1872 {
1873 aRet <<= getAllVersions( xEnv );
1874 }
1875 else if ( aCommand.Name == "updateProperties" )
1876 {
1877 updateProperties( aCommand.Argument, xEnv );
1878 }
1879 else
1880 {
1881 SAL_INFO( "ucb.ucp.cmis", "Unknown command to execute" );
1882
1883 ucbhelper::cancelCommandExecution
1884 ( uno::Any( ucb::UnsupportedCommandException
1885 ( OUString(),
1886 static_cast< cppu::OWeakObject * >( this ) ) ),
1887 xEnv );
1888 }
1889
1890 return aRet;
1891 }
1892
1893 void SAL_CALL Content::abort( sal_Int32 /*CommandId*/ )
1894 {
1895 SAL_INFO( "ucb.ucp.cmis", "TODO - Content::abort()" );
1896 // TODO Implement me
1897 }
1898
1899 uno::Sequence< ucb::ContentInfo > SAL_CALL Content::queryCreatableContentsInfo()
1900 {
1901 return queryCreatableContentsInfo( uno::Reference< ucb::XCommandEnvironment >() );
1902 }
1903
1904 uno::Reference< ucb::XContent > SAL_CALL Content::createNewContent(
1905 const ucb::ContentInfo& Info )
1906 {
1907 bool create_document;
1908
1909 if ( Info.Type == CMIS_FILE_TYPE )
1910 create_document = true;
1911 else if ( Info.Type == CMIS_FOLDER_TYPE )
1912 create_document = false;
1913 else
1914 {
1915 SAL_INFO( "ucb.ucp.cmis", "Unknown type of content to create" );
1916 return uno::Reference< ucb::XContent >();
1917 }
1918
1919 OUString sParentURL = m_xIdentifier->getContentIdentifier();
1920
1921 // Set the parent URL for the transient objects
1922 uno::Reference< ucb::XContentIdentifier > xId(new ::ucbhelper::ContentIdentifier(sParentURL));
1923
1924 try
1925 {
1926 return new ::cmis::Content( m_xContext, m_pProvider, xId, !create_document );
1927 }
1928 catch ( ucb::ContentCreationException & )
1929 {
1930 return uno::Reference< ucb::XContent >();
1931 }
1932 }
1933
1934 uno::Sequence< uno::Type > SAL_CALL Content::getTypes()
1935 {
1936 try
1937 {
1938 if ( isFolder( uno::Reference< ucb::XCommandEnvironment >() ) )
1939 {
1940 static cppu::OTypeCollection s_aFolderCollection
1941 (CPPU_TYPE_REF( lang::XTypeProvider ),
1942 CPPU_TYPE_REF( lang::XServiceInfo ),
1943 CPPU_TYPE_REF( lang::XComponent ),
1944 CPPU_TYPE_REF( ucb::XContent ),
1945 CPPU_TYPE_REF( ucb::XCommandProcessor ),
1946 CPPU_TYPE_REF( beans::XPropertiesChangeNotifier ),
1947 CPPU_TYPE_REF( ucb::XCommandInfoChangeNotifier ),
1948 CPPU_TYPE_REF( beans::XPropertyContainer ),
1949 CPPU_TYPE_REF( beans::XPropertySetInfoChangeNotifier ),
1950 CPPU_TYPE_REF( container::XChild ),
1951 CPPU_TYPE_REF( ucb::XContentCreator ) );
1952 return s_aFolderCollection.getTypes();
1953 }
1954 }
1955 catch (const uno::RuntimeException&)
1956 {
1957 throw;
1958 }
1959 catch (const uno::Exception& e)
1960 {
1961 uno::Any a(cppu::getCaughtException());
1962 throw lang::WrappedTargetRuntimeException(
1963 "wrapped Exception " + e.Message,
1964 uno::Reference<uno::XInterface>(), a);
1965 }
1966
1967 static cppu::OTypeCollection s_aFileCollection
1968 (CPPU_TYPE_REF( lang::XTypeProvider ),
1969 CPPU_TYPE_REF( lang::XServiceInfo ),
1970 CPPU_TYPE_REF( lang::XComponent ),
1971 CPPU_TYPE_REF( ucb::XContent ),
1972 CPPU_TYPE_REF( ucb::XCommandProcessor ),
1973 CPPU_TYPE_REF( beans::XPropertiesChangeNotifier ),
1974 CPPU_TYPE_REF( ucb::XCommandInfoChangeNotifier ),
1975 CPPU_TYPE_REF( beans::XPropertyContainer ),
1976 CPPU_TYPE_REF( beans::XPropertySetInfoChangeNotifier ),
1977 CPPU_TYPE_REF( container::XChild ) );
1978
1979 return s_aFileCollection.getTypes();
1980 }
1981
1982 uno::Sequence< ucb::ContentInfo > Content::queryCreatableContentsInfo(
1983 const uno::Reference< ucb::XCommandEnvironment >& xEnv)
1984 {
1985 try
1986 {
1987 if ( isFolder( xEnv ) )
1988 {
1989
1990 // Minimum set of props we really need
1991 uno::Sequence< beans::Property > props
1992 {
1993 {
1994 "Title",
1995 -1,
1996 cppu::UnoType<OUString>::get(),
1997 beans::PropertyAttribute::MAYBEVOID | beans::PropertyAttribute::BOUND
1998 }
1999 };
2000
2001 return
2002 {
2003 {
2004 CMIS_FILE_TYPE,
2005 ( ucb::ContentInfoAttribute::INSERT_WITH_INPUTSTREAM |
2006 ucb::ContentInfoAttribute::KIND_DOCUMENT ),
2007 props
2008 },
2009 {
2010 CMIS_FOLDER_TYPE,
2011 ucb::ContentInfoAttribute::KIND_FOLDER,
2012 props
2013 }
2014 };
2015 }
2016 }
2017 catch (const uno::RuntimeException&)
2018 {
2019 throw;
2020 }
2021 catch (const uno::Exception& e)
2022 {
2023 uno::Any a(cppu::getCaughtException());
2024 throw lang::WrappedTargetRuntimeException(
2025 "wrapped Exception " + e.Message,
2026 uno::Reference<uno::XInterface>(), a);
2027 }
2028 return {};
2029 }
2030
2031 std::vector< uno::Reference< ucb::XContent > > Content::getChildren( )
2032 {
2033 std::vector< uno::Reference< ucb::XContent > > results;
2034 SAL_INFO( "ucb.ucp.cmis", "Content::getChildren() " << m_sURL );
2035
2036 libcmis::FolderPtr pFolder = boost::dynamic_pointer_cast< libcmis::Folder >( getObject( uno::Reference< ucb::XCommandEnvironment >() ) );
2037 if ( nullptr != pFolder )
2038 {
2039 // Get the children from pObject
2040 try
2041 {
2042 std::vector< libcmis::ObjectPtr > children = pFolder->getChildren( );
2043
2044 // Loop over the results
2045 for ( const auto& rChild : children )
2046 {
2047 // TODO Cache the objects
2048
2049 INetURLObject aURL( m_sURL );
2050 OUString sUser = aURL.GetUser( INetURLObject::DecodeMechanism::WithCharset );
2051
2052 URL aUrl( m_sURL );
2053 OUString sPath( m_sObjectPath );
2054 if ( !sPath.endsWith("/") )
2055 sPath += "/";
2056 sPath += STD_TO_OUSTR( rChild->getName( ) );
2057 OUString sId = STD_TO_OUSTR( rChild->getId( ) );
2058
2059 aUrl.setObjectId( sId );
2060 aUrl.setObjectPath( sPath );
2061 aUrl.setUsername( sUser );
2062
2063 uno::Reference< ucb::XContentIdentifier > xId = new ucbhelper::ContentIdentifier( aUrl.asString( ) );
2064 uno::Reference< ucb::XContent > xContent = new Content( m_xContext, m_pProvider, xId, rChild );
2065
2066 results.push_back( xContent );
2067 }
2068 }
2069 catch ( const libcmis::Exception& e )
2070 {
2071 SAL_INFO( "ucb.ucp.cmis", "Exception thrown: " << e.what() );
2072 }
2073 }
2074
2075 return results;
2076 }
2077
2078 void Content::setCmisProperty(const std::string& rName, const std::string& rValue, const uno::Reference< ucb::XCommandEnvironment >& xEnv )
2079 {
2080 if ( !getObjectType( xEnv ).get( ) )
2081 return;
2082
2083 std::map< std::string, libcmis::PropertyPtr >::iterator propIt = m_pObjectProps.find(rName);
2084
2085 if ( propIt == m_pObjectProps.end( ) && getObjectType( xEnv ).get( ) )
2086 {
2087 std::map< std::string, libcmis::PropertyTypePtr > propsTypes = getObjectType( xEnv )->getPropertiesTypes( );
2088 std::map< std::string, libcmis::PropertyTypePtr >::iterator typeIt = propsTypes.find(rName);
2089
2090 if ( typeIt != propsTypes.end( ) )
2091 {
2092 libcmis::PropertyTypePtr propType = typeIt->second;
2093 libcmis::PropertyPtr property( new libcmis::Property( propType, { rValue }) );
2094 m_pObjectProps.insert(std::pair< std::string, libcmis::PropertyPtr >(rName, property));
2095 }
2096 }
2097 else if ( propIt != m_pObjectProps.end( ) )
2098 {
2099 propIt->second->setValues( { rValue } );
2100 }
2101 }
2102 }
2103
2104 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE