extensions/source/abpilot/datasourcehandling.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
  21 #include "abpresid.hrc"
  22 #include "abptypes.hxx"
  23 #include "componentmodule.hxx"
  24 #include "datasourcehandling.hxx"
  25
  26 #include <boost/noncopyable.hpp>
  27 #include <com/sun/star/beans/XPropertySet.hpp>
  28 #include <com/sun/star/container/XNameAccess.hpp>
  29 #include <com/sun/star/frame/XStorable.hpp>
  30 #include <com/sun/star/lang/XComponent.hpp>
  31 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  32 #include <com/sun/star/sdb/DatabaseContext.hpp>
  33 #include <com/sun/star/sdb/SQLContext.hpp>
  34 #include <com/sun/star/sdb/XCompletedConnection.hpp>
  35 #include <com/sun/star/sdb/XDatabaseRegistrations.hpp>
  36 #include <com/sun/star/sdb/XDocumentDataSource.hpp>
  37 #include <com/sun/star/sdbc/XConnection.hpp>
  38 #include <com/sun/star/sdbcx/XTablesSupplier.hpp>
  39 #include <com/sun/star/task/InteractionHandler.hpp>
  40 #include <com/sun/star/uno/XNamingService.hpp>
  41
  42 #include <comphelper/interaction.hxx>
  43 #include <comphelper/processfactory.hxx>
  44 #include <tools/debug.hxx>
  45 #include <tools/diagnose_ex.h>
  46 #include <unotools/confignode.hxx>
  47 #include <unotools/sharedunocomponent.hxx>
  48 #include <vcl/stdtext.hxx>
  49
  50
  51 namespace abp
  52 {
  53
  54
  55     using namespace ::utl;
  56     using namespace ::comphelper;
  57     using namespace ::com::sun::star::uno;
  58     using namespace ::com::sun::star::lang;
  59     using namespace ::com::sun::star::sdb;
  60     using namespace ::com::sun::star::sdbc;
  61     using namespace ::com::sun::star::task;
  62     using namespace ::com::sun::star::beans;
  63     using namespace ::com::sun::star::sdbcx;
  64     using namespace ::com::sun::star::container;
  65     using namespace ::com::sun::star::frame;
  66
  67
  68     struct PackageAccessControl { };
  69
  70
  71
  72     static Reference< XDatabaseContext > lcl_getDataSourceContext( const Reference< XComponentContext >& _rxContext )
  73     {
  74         Reference<XDatabaseContext> xContext = DatabaseContext::create(_rxContext);
  75         return xContext;
  76     }
  77
  78
  79     /// creates a new data source and inserts it into the context
  80     static void lcl_implCreateAndInsert(
  81         const Reference< XComponentContext >& _rxContext, const OUString& _rName,
  82         Reference< XPropertySet >& /* [out] */ _rxNewDataSource )
  83     {
  84
  85         // get the data source context
  86         Reference< XDatabaseContext > xContext = lcl_getDataSourceContext( _rxContext );
  87
  88         DBG_ASSERT( !xContext->hasByName( _rName ), "lcl_implCreateAndInsert: name already used!" );
  89         (void)_rName;
  90
  91
  92         // create a new data source
  93         Reference< XPropertySet > xNewDataSource;
  94         if (xContext.is())
  95             xNewDataSource = Reference< XPropertySet >( xContext->createInstance(), UNO_QUERY );
  96         DBG_ASSERT( xNewDataSource.is(), "lcl_implCreateAndInsert: could not create a new data source!" );
  97
  98
  99         // insert the data source into the context
 100         DBG_ASSERT( xContext.is(), "lcl_implCreateAndInsert: missing an interface on the context (XNamingService)!" );
 101         if (xContext.is())
 102         {
 103             //  xDynamicContext->registerObject( _rName, xNewDataSource );
 104             _rxNewDataSource = xNewDataSource;
 105         }
 106     }
 107
 108
 109     /// creates and inserts a data source, and sets its URL property to the string given
 110     static ODataSource lcl_implCreateAndSetURL(
 111         const Reference< XComponentContext >& _rxORB, const OUString& _rName,
 112         const sal_Char* _pInitialAsciiURL )
 113     {
 114         ODataSource aReturn( _rxORB );
 115         try
 116         {
 117             // create the new data source
 118             Reference< XPropertySet > xNewDataSource;
 119             lcl_implCreateAndInsert( _rxORB, _rName, xNewDataSource );
 120
 121
 122             // set the URL property
 123             if (xNewDataSource.is())
 124             {
 125                 xNewDataSource->setPropertyValue(
 126                     OUString( "URL" ),
 127                     makeAny( OUString::createFromAscii( _pInitialAsciiURL ) )
 128                 );
 129             }
 130
 131             aReturn.setDataSource( xNewDataSource, _rName,PackageAccessControl() );
 132         }
 133         catch(const Exception&)
 134         {
 135             OSL_FAIL( "lcl_implCreateAndSetURL: caught an exception while creating the data source!" );
 136         }
 137
 138         return aReturn;
 139     }
 140
 141     void lcl_registerDataSource(
 142         const Reference< XComponentContext >& _rxORB, const OUString& _sName,
 143         const OUString& _sURL )
 144     {
 145         OSL_ENSURE( !_sName.isEmpty(), "lcl_registerDataSource: invalid name!" );
 146         OSL_ENSURE( !_sURL.isEmpty(), "lcl_registerDataSource: invalid URL!" );
 147         try
 148         {
 149             Reference< XDatabaseContext > xRegistrations( DatabaseContext::create(_rxORB) );
 150             if ( xRegistrations->hasRegisteredDatabase( _sName ) )
 151                 xRegistrations->changeDatabaseLocation( _sName, _sURL );
 152             else
 153                 xRegistrations->registerDatabaseLocation( _sName, _sURL );
 154         }
 155         catch( const Exception& )
 156         {
 157             DBG_UNHANDLED_EXCEPTION();
 158         }
 159     }
 160
 161     struct ODataSourceContextImpl: private boost::noncopyable
 162     {
 163         Reference< XComponentContext >      xORB;
 164         Reference< XNameAccess >            xContext;           /// the UNO data source context
 165         StringBag                           aDataSourceNames;   /// for quicker name checks (without the UNO overhead)
 166
 167         ODataSourceContextImpl( const Reference< XComponentContext >& _rxORB ) : xORB( _rxORB ) { }
 168     };
 169
 170     ODataSourceContext::ODataSourceContext(const Reference< XComponentContext >& _rxORB)
 171         :m_pImpl( new ODataSourceContextImpl( _rxORB ) )
 172     {
 173         try
 174         {
 175             // create the UNO context
 176             m_pImpl->xContext = Reference<XNameAccess>(
 177                       lcl_getDataSourceContext( _rxORB ),
 178                       UNO_QUERY_THROW);
 179
 180             if (m_pImpl->xContext.is())
 181             {
 182                 // collect the data source names
 183                 Sequence< OUString > aDSNames = m_pImpl->xContext->getElementNames();
 184                 const OUString* pDSNames = aDSNames.getConstArray();
 185                 const OUString* pDSNamesEnd = pDSNames + aDSNames.getLength();
 186
 187                 for ( ;pDSNames != pDSNamesEnd; ++pDSNames )
 188                     m_pImpl->aDataSourceNames.insert( *pDSNames );
 189             }
 190         }
 191         catch( const Exception& )
 192         {
 193             OSL_FAIL( "ODataSourceContext::ODataSourceContext: caught an exception!" );
 194         }
 195     }
 196     ODataSourceContext::~ODataSourceContext()
 197     {
 198         delete(m_pImpl);
 199     }
 200
 201
 202     OUString& ODataSourceContext::disambiguate(OUString& _rDataSourceName)
 203     {
 204         OUString sCheck( _rDataSourceName );
 205         StringBag::const_iterator aPos = m_pImpl->aDataSourceNames.find( sCheck );
 206
 207         sal_Int32 nPostfix = 1;
 208         while ( ( m_pImpl->aDataSourceNames.end() != aPos ) && ( nPostfix < 65535 ) )
 209         {   // there already is a data source with this name
 210             sCheck = _rDataSourceName;
 211             sCheck += OUString::number( nPostfix++ );
 212
 213             aPos = m_pImpl->aDataSourceNames.find( sCheck );
 214         }
 215
 216         _rDataSourceName = sCheck;
 217         return _rDataSourceName;
 218     }
 219
 220
 221     void ODataSourceContext::getDataSourceNames( StringBag& _rNames ) const
 222     {
 223         _rNames = m_pImpl->aDataSourceNames;
 224     }
 225
 226
 227     ODataSource ODataSourceContext::createNewLDAP( const OUString& _rName)
 228     {
 229         return lcl_implCreateAndSetURL( m_pImpl->xORB, _rName, "sdbc:address:ldap:" );
 230     }
 231
 232
 233     ODataSource ODataSourceContext::createNewMORK( const OUString& _rName)
 234     {
 235         return lcl_implCreateAndSetURL( m_pImpl->xORB, _rName, "sdbc:address:mozilla" );
 236     }
 237
 238
 239     ODataSource ODataSourceContext::createNewThunderbird( const OUString& _rName )
 240     {
 241         return lcl_implCreateAndSetURL( m_pImpl->xORB, _rName, "sdbc:address:thunderbird" );
 242     }
 243
 244
 245     ODataSource ODataSourceContext::createNewEvolutionLdap( const OUString& _rName)
 246     {
 247         return lcl_implCreateAndSetURL( m_pImpl->xORB, _rName, "sdbc:address:evolution:ldap" );
 248     }
 249
 250     ODataSource ODataSourceContext::createNewEvolutionGroupwise( const OUString& _rName)
 251     {
 252         return lcl_implCreateAndSetURL( m_pImpl->xORB, _rName, "sdbc:address:evolution:groupwise" );
 253     }
 254
 255     ODataSource ODataSourceContext::createNewEvolution( const OUString& _rName)
 256     {
 257         return lcl_implCreateAndSetURL( m_pImpl->xORB, _rName, "sdbc:address:evolution:local" );
 258     }
 259
 260
 261     ODataSource ODataSourceContext::createNewKab( const OUString& _rName)
 262     {
 263         return lcl_implCreateAndSetURL( m_pImpl->xORB, _rName, "sdbc:address:kab" );
 264     }
 265
 266
 267     ODataSource ODataSourceContext::createNewMacab( const OUString& _rName)
 268     {
 269         return lcl_implCreateAndSetURL( m_pImpl->xORB, _rName, "sdbc:address:macab" );
 270     }
 271
 272
 273     ODataSource ODataSourceContext::createNewOutlook( const OUString& _rName)
 274     {
 275         return lcl_implCreateAndSetURL( m_pImpl->xORB, _rName, "sdbc:address:outlook" );
 276     }
 277
 278
 279     ODataSource ODataSourceContext::createNewOE( const OUString& _rName)
 280     {
 281         return lcl_implCreateAndSetURL( m_pImpl->xORB, _rName, "sdbc:address:outlookexp" );
 282     }
 283
 284
 285     ODataSource ODataSourceContext::createNewDBase( const OUString& _rName)
 286     {
 287         return lcl_implCreateAndSetURL( m_pImpl->xORB, _rName, "sdbc:dbase:" );
 288     }
 289
 290     struct ODataSourceImpl
 291     {
 292     public:
 293         Reference< XComponentContext >          xORB;               /// the service factory
 294         Reference< XPropertySet >               xDataSource;        /// the UNO data source
 295         ::utl::SharedUNOComponent< XConnection >
 296                                                 xConnection;
 297         StringBag                               aTables;            // the cached table names
 298         OUString                         sName;
 299         bool                                bTablesUpToDate;    // table name cache up-to-date?
 300
 301         ODataSourceImpl( const Reference< XComponentContext >& _rxORB )
 302             :xORB( _rxORB )
 303             ,bTablesUpToDate( false )
 304         {
 305         }
 306
 307         ODataSourceImpl( const ODataSourceImpl& _rSource );
 308     };
 309
 310
 311     ODataSourceImpl::ODataSourceImpl( const ODataSourceImpl& _rSource )
 312         :xORB( _rSource.xORB )
 313         ,xDataSource( _rSource.xDataSource )
 314         ,xConnection( _rSource.xConnection )
 315         ,aTables( _rSource.aTables )
 316         ,sName( _rSource.sName )
 317         ,bTablesUpToDate( _rSource.bTablesUpToDate )
 318     {
 319     }
 320
 321     ODataSource::ODataSource( const ODataSource& _rSource )
 322         :m_pImpl( NULL )
 323     {
 324         *this = _rSource;
 325     }
 326
 327
 328     ODataSource& ODataSource::operator=( const ODataSource& _rSource )
 329     {
 330         if( this != &_rSource )
 331         {
 332             delete m_pImpl;
 333             m_pImpl = new ODataSourceImpl( *_rSource.m_pImpl );
 334         }
 335         return *this;
 336     }
 337
 338
 339     ODataSource::ODataSource( const Reference< XComponentContext >& _rxORB )
 340         :m_pImpl(new ODataSourceImpl(_rxORB))
 341     {
 342     }
 343
 344
 345     ODataSource::~ODataSource( )
 346     {
 347         delete m_pImpl;
 348     }
 349
 350
 351     void ODataSource::store()
 352     {
 353         if (!isValid())
 354             // nothing to do
 355             return;
 356         try
 357         {
 358             Reference< XDocumentDataSource > xDocAccess( m_pImpl->xDataSource, UNO_QUERY );
 359             Reference< XStorable > xStorable;
 360             if ( xDocAccess.is() )
 361                 xStorable.set(xDocAccess->getDatabaseDocument(), css::uno::UNO_QUERY);
 362             OSL_ENSURE( xStorable.is(),"DataSource is no XStorable!" );
 363             if ( xStorable.is() )
 364                 xStorable->storeAsURL(m_pImpl->sName,Sequence<PropertyValue>());
 365         }
 366         catch(const Exception&)
 367         {
 368             OSL_FAIL( "ODataSource::registerDataSource: caught an exception while creating the data source!" );
 369         }
 370     }
 371
 372     void ODataSource::registerDataSource( const OUString& _sRegisteredDataSourceName)
 373     {
 374         if (!isValid())
 375             // nothing to do
 376             return;
 377
 378         try
 379         {
 380             // invalidate ourself
 381             lcl_registerDataSource(m_pImpl->xORB,_sRegisteredDataSourceName,m_pImpl->sName);
 382         }
 383         catch(const Exception&)
 384         {
 385             OSL_FAIL( "ODataSource::registerDataSource: caught an exception while creating the data source!" );
 386         }
 387     }
 388
 389
 390     void ODataSource::setDataSource( const Reference< XPropertySet >& _rxDS,const OUString& _sName, PackageAccessControl )
 391     {
 392         if (m_pImpl->xDataSource.get() == _rxDS.get())
 393             // nothing to do
 394             return;
 395
 396         if ( isConnected() )
 397             disconnect();
 398
 399         m_pImpl->sName = _sName;
 400         m_pImpl->xDataSource = _rxDS;
 401     }
 402
 403
 404     void ODataSource::remove()
 405     {
 406         if (!isValid())
 407             // nothing to do
 408             return;
 409
 410         try
 411         {
 412             // invalidate ourself
 413             m_pImpl->xDataSource.clear();
 414         }
 415         catch(const Exception&)
 416         {
 417             OSL_FAIL( "ODataSource::remove: caught an exception while creating the data source!" );
 418         }
 419     }
 420
 421
 422     bool ODataSource::rename( const OUString& _rName )
 423     {
 424         if (!isValid())
 425             // nothing to do
 426             return false;
 427
 428         m_pImpl->sName = _rName;
 429         return true;
 430     }
 431
 432
 433     OUString ODataSource::getName() const
 434     {
 435         if ( !isValid() )
 436             return OUString();
 437         return m_pImpl->sName;
 438     }
 439
 440
 441     bool ODataSource::hasTable( const OUString& _rTableName ) const
 442     {
 443         if ( !isConnected() )
 444             return false;
 445
 446         const StringBag& aTables( getTableNames() );
 447         return aTables.find( _rTableName ) != aTables.end();
 448     }
 449
 450
 451     const StringBag& ODataSource::getTableNames() const
 452     {
 453         m_pImpl->aTables.clear();
 454         if ( !isConnected() )
 455         {
 456             OSL_FAIL( "ODataSource::getTableNames: not connected!" );
 457         }
 458         else
 459         {
 460             try
 461             {
 462                 // get the tables container from the connection
 463                 Reference< XTablesSupplier > xSuppTables( m_pImpl->xConnection.getTyped(), UNO_QUERY );
 464                 Reference< XNameAccess > xTables;
 465                 if ( xSuppTables.is( ) )
 466                     xTables = xSuppTables->getTables();
 467                 DBG_ASSERT( xTables.is(), "ODataSource::getTableNames: could not retrieve the tables container!" );
 468
 469                 // get the names
 470                 Sequence< OUString > aTableNames;
 471                 if ( xTables.is( ) )
 472                     aTableNames = xTables->getElementNames( );
 473
 474                 // copy the names
 475                 const OUString* pTableNames = aTableNames.getConstArray();
 476                 const OUString* pTableNamesEnd = pTableNames + aTableNames.getLength();
 477                 for (;pTableNames < pTableNamesEnd; ++pTableNames)
 478                     m_pImpl->aTables.insert( *pTableNames );
 479             }
 480             catch(const Exception&)
 481             {
 482             }
 483         }
 484
 485         // now the table cache is up-to-date
 486         m_pImpl->bTablesUpToDate = true;
 487         return m_pImpl->aTables;
 488     }
 489
 490
 491     bool ODataSource::connect( vcl::Window* _pMessageParent )
 492     {
 493         if ( isConnected( ) )
 494             // nothing to do
 495             return true;
 496
 497
 498         // create the interaction handler (needed for authentication and error handling)
 499         Reference< XInteractionHandler > xInteractions;
 500         try
 501         {
 502             xInteractions.set(
 503                 InteractionHandler::createWithParent(m_pImpl->xORB, 0),
 504                 UNO_QUERY);
 505         }
 506         catch(const Exception&)
 507         {
 508         }
 509
 510
 511         // failure to create the interaction handler is a serious issue ...
 512         if (!xInteractions.is())
 513         {
 514             OUString s_sInteractionHandlerServiceName("com.sun.star.task.InteractionHandler");
 515             if ( _pMessageParent )
 516                 ShowServiceNotAvailableError( _pMessageParent, s_sInteractionHandlerServiceName, true );
 517             return false;
 518         }
 519
 520
 521         // open the connection
 522         Any aError;
 523         Reference< XConnection > xConnection;
 524         try
 525         {
 526             Reference< XCompletedConnection > xComplConn( m_pImpl->xDataSource, UNO_QUERY );
 527             DBG_ASSERT( xComplConn.is(), "ODataSource::connect: missing the XCompletedConnection interface on the data source!" );
 528             if ( xComplConn.is() )
 529                 xConnection = xComplConn->connectWithCompletion( xInteractions );
 530         }
 531         catch( const SQLContext& e ) { aError <<= e; }
 532         catch( const SQLWarning& e ) { aError <<= e; }
 533         catch( const SQLException& e ) { aError <<= e; }
 534         catch( const Exception& )
 535         {
 536             OSL_FAIL( "ODataSource::connect: caught a generic exception!" );
 537         }
 538
 539
 540         // handle errors
 541         if ( aError.hasValue() && _pMessageParent )
 542         {
 543             try
 544             {
 545                 SQLException aException;
 546                   aError >>= aException;
 547                   if ( aException.Message.isEmpty() )
 548                   {
 549                     // prepend some context info
 550                     SQLContext aDetailedError;
 551                     aDetailedError.Message = ModuleRes(RID_STR_NOCONNECTION).toString();
 552                     aDetailedError.Details = ModuleRes(RID_STR_PLEASECHECKSETTINGS).toString();
 553                     aDetailedError.NextException = aError;
 554                     // handle (aka display) the new context info
 555                     xInteractions->handle( new OInteractionRequest( makeAny( aDetailedError ) ) );
 556                   }
 557                   else
 558                   {
 559                       // handle (aka display) the original error
 560                     xInteractions->handle( new OInteractionRequest( makeAny( aException ) ) );
 561                 }
 562             }
 563             catch( const Exception& )
 564             {
 565                 OSL_FAIL( "ODataSource::connect: caught an exception while trying to display the error!" );
 566             }
 567         }
 568
 569         if ( !xConnection.is() )
 570             return false;
 571
 572
 573         // success
 574         m_pImpl->xConnection.reset( xConnection );
 575         m_pImpl->aTables.clear();
 576         m_pImpl->bTablesUpToDate = false;
 577
 578         return true;
 579     }
 580
 581
 582     void ODataSource::disconnect( )
 583     {
 584         m_pImpl->xConnection.clear();
 585         m_pImpl->aTables.clear();
 586         m_pImpl->bTablesUpToDate = false;
 587     }
 588
 589
 590     bool ODataSource::isConnected( ) const
 591     {
 592         return m_pImpl->xConnection.is();
 593     }
 594
 595
 596     bool ODataSource::isValid() const
 597     {
 598         return m_pImpl && m_pImpl->xDataSource.is();
 599     }
 600
 601     Reference< XPropertySet > ODataSource::getDataSource() const
 602     {
 603         return m_pImpl ? m_pImpl->xDataSource : Reference< XPropertySet >();
 604     }
 605
 606
 607 }   // namespace abp
 608
 609
 610 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */