| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_dbaccess.hxx" |
| |
| #include "DbAdminImpl.hxx" |
| #include "dsmeta.hxx" |
| |
| #include <svl/poolitem.hxx> |
| #include <svl/itempool.hxx> |
| #include <svl/stritem.hxx> |
| #include <svl/intitem.hxx> |
| #include <svl/eitem.hxx> |
| #include "DriverSettings.hxx" |
| #include "IItemSetHelper.hxx" |
| #include "UITools.hxx" |
| #include "dbu_dlg.hrc" |
| #include "dbustrings.hrc" |
| #include "dsitems.hxx" |
| #include "dsnItem.hxx" |
| #include "moduledbu.hxx" |
| #include "optionalboolitem.hxx" |
| #include "propertysetitem.hxx" |
| #include "stringlistitem.hxx" |
| #include "OAuthenticationContinuation.hxx" |
| |
| /** === begin UNO includes === **/ |
| #include <com/sun/star/beans/PropertyAttribute.hpp> |
| #include <com/sun/star/frame/XStorable.hpp> |
| #include <com/sun/star/sdb/SQLContext.hpp> |
| #include <com/sun/star/sdbc/XDriver.hpp> |
| #include <com/sun/star/sdbc/XDriverAccess.hpp> |
| #include <com/sun/star/task/XInteractionHandler.hpp> |
| #include <com/sun/star/task/XInteractionRequest.hpp> |
| #include <com/sun/star/ucb/XInteractionSupplyAuthentication2.hpp> |
| #include <com/sun/star/ucb/AuthenticationRequest.hpp> |
| /** === end UNO includes === **/ |
| |
| #include <comphelper/interaction.hxx> |
| #include <comphelper/property.hxx> |
| #include <comphelper/sequence.hxx> |
| #include <comphelper/guarding.hxx> |
| #include <connectivity/DriversConfig.hxx> |
| #include <connectivity/dbexception.hxx> |
| #include <osl/file.hxx> |
| #include <svl/eitem.hxx> |
| #include <svl/intitem.hxx> |
| #include <svl/itempool.hxx> |
| #include <svl/poolitem.hxx> |
| #include <svl/stritem.hxx> |
| #include <tools/urlobj.hxx> |
| #include <tools/diagnose_ex.h> |
| #include <typelib/typedescription.hxx> |
| #include <vcl/svapp.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <vcl/stdtext.hxx> |
| #include <vcl/waitobj.hxx> |
| #include <vos/mutex.hxx> |
| |
| #include <algorithm> |
| #include <functional> |
| //......................................................................... |
| namespace dbaui |
| { |
| //......................................................................... |
| using namespace ::dbtools; |
| using namespace com::sun::star::uno; |
| using namespace com::sun::star; |
| using namespace com::sun::star::ucb; |
| using namespace com::sun::star::task; |
| using namespace com::sun::star::sdbc; |
| using namespace com::sun::star::sdb; |
| using namespace com::sun::star::lang; |
| using namespace com::sun::star::beans; |
| using namespace com::sun::star::util; |
| using namespace com::sun::star::container; |
| using namespace com::sun::star::frame; |
| |
| //------------------------------------------------------------------------- |
| namespace |
| { |
| sal_Bool implCheckItemType( SfxItemSet& _rSet, const sal_uInt16 _nId, const TypeId _nExpectedItemType ) |
| { |
| sal_Bool bCorrectType = sal_False; |
| |
| SfxItemPool* pPool = _rSet.GetPool(); |
| DBG_ASSERT( pPool, "implCheckItemType: invalid item pool!" ); |
| if ( pPool ) |
| { |
| const SfxPoolItem& rDefItem = pPool->GetDefaultItem( _nId ); |
| bCorrectType = rDefItem.IsA( _nExpectedItemType ); |
| } |
| return bCorrectType; |
| } |
| |
| void lcl_putProperty(const Reference< XPropertySet >& _rxSet, const ::rtl::OUString& _rName, const Any& _rValue) |
| { |
| try |
| { |
| if ( _rxSet.is() ) |
| _rxSet->setPropertyValue(_rName, _rValue); |
| } |
| catch(Exception&) |
| { |
| #ifdef DBG_UTIL |
| ::rtl::OString sMessage("ODbAdminDialog::implTranslateProperty: could not set the property "); |
| sMessage += ::rtl::OString(_rName.getStr(), _rName.getLength(), RTL_TEXTENCODING_ASCII_US); |
| sMessage += ::rtl::OString("!"); |
| DBG_ERROR(sMessage.getStr()); |
| #endif |
| } |
| |
| } |
| |
| String lcl_createHostWithPort(const SfxStringItem* _pHostName,const SfxInt32Item* _pPortNumber) |
| { |
| String sNewUrl; |
| |
| if ( _pHostName && _pHostName->GetValue().Len() ) |
| sNewUrl = _pHostName->GetValue(); |
| |
| if ( _pPortNumber ) |
| { |
| sNewUrl += String::CreateFromAscii(":"); |
| sNewUrl += String::CreateFromInt32(_pPortNumber->GetValue()); |
| } |
| |
| return sNewUrl; |
| } |
| } |
| |
| //======================================================================== |
| //= ODbDataSourceAdministrationHelper |
| //======================================================================== |
| ODbDataSourceAdministrationHelper::ODbDataSourceAdministrationHelper(const Reference< XMultiServiceFactory >& _xORB,Window* _pParent,IItemSetHelper* _pItemSetHelper) |
| : m_xORB(_xORB) |
| , m_pParent(_pParent) |
| , m_pItemSetHelper(_pItemSetHelper) |
| { |
| /// initialize the property translation map |
| // direct properties of a data source |
| m_aDirectPropTranslator.insert(MapInt2String::value_type(DSID_CONNECTURL, PROPERTY_URL)); |
| m_aDirectPropTranslator.insert(MapInt2String::value_type(DSID_NAME, PROPERTY_NAME)); |
| m_aDirectPropTranslator.insert(MapInt2String::value_type(DSID_USER, PROPERTY_USER)); |
| m_aDirectPropTranslator.insert(MapInt2String::value_type(DSID_PASSWORD, PROPERTY_PASSWORD)); |
| m_aDirectPropTranslator.insert(MapInt2String::value_type(DSID_PASSWORDREQUIRED, PROPERTY_ISPASSWORDREQUIRED)); |
| m_aDirectPropTranslator.insert(MapInt2String::value_type(DSID_TABLEFILTER, PROPERTY_TABLEFILTER)); |
| m_aDirectPropTranslator.insert(MapInt2String::value_type(DSID_READONLY, PROPERTY_ISREADONLY)); |
| m_aDirectPropTranslator.insert(MapInt2String::value_type(DSID_SUPPRESSVERSIONCL, PROPERTY_SUPPRESSVERSIONCL)); |
| |
| // implicit properties, to be found in the direct property "Info" |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_JDBCDRIVERCLASS, INFO_JDBCDRIVERCLASS)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_TEXTFILEEXTENSION, INFO_TEXTFILEEXTENSION)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_CHARSET, INFO_CHARSET)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_TEXTFILEHEADER, INFO_TEXTFILEHEADER)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_FIELDDELIMITER, INFO_FIELDDELIMITER)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_TEXTDELIMITER, INFO_TEXTDELIMITER)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_DECIMALDELIMITER, INFO_DECIMALDELIMITER)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_THOUSANDSDELIMITER, INFO_THOUSANDSDELIMITER)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_SHOWDELETEDROWS, INFO_SHOWDELETEDROWS)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_ALLOWLONGTABLENAMES, INFO_ALLOWLONGTABLENAMES)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_ADDITIONALOPTIONS, INFO_ADDITIONALOPTIONS)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_SQL92CHECK, PROPERTY_ENABLESQL92CHECK)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_AUTOINCREMENTVALUE, PROPERTY_AUTOINCREMENTCREATION)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_AUTORETRIEVEVALUE, INFO_AUTORETRIEVEVALUE)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_AUTORETRIEVEENABLED, INFO_AUTORETRIEVEENABLED)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_APPEND_TABLE_ALIAS, INFO_APPEND_TABLE_ALIAS)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_AS_BEFORE_CORRNAME, INFO_AS_BEFORE_CORRELATION_NAME ) ); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_CHECK_REQUIRED_FIELDS, INFO_FORMS_CHECK_REQUIRED_FIELDS ) ); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_ESCAPE_DATETIME, INFO_ESCAPE_DATETIME ) ); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_PRIMARY_KEY_SUPPORT, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "PrimaryKeySupport" ) ) ) ); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_PARAMETERNAMESUBST, INFO_PARAMETERNAMESUBST)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_IGNOREDRIVER_PRIV, INFO_IGNOREDRIVER_PRIV)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_BOOLEANCOMPARISON, PROPERTY_BOOLEANCOMPARISONMODE)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_ENABLEOUTERJOIN, PROPERTY_ENABLEOUTERJOIN)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_CATALOG, PROPERTY_USECATALOGINSELECT)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_SCHEMA, PROPERTY_USESCHEMAINSELECT)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_INDEXAPPENDIX, ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AddIndexAppendix")))); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_DOSLINEENDS, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "PreferDosLikeLineEnds" ) ) ) ); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_CONN_SOCKET, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LocalSocket" ) ) ) ); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_NAMED_PIPE, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "NamedPipe" ) ) ) ); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_RESPECTRESULTSETTYPE, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "RespectDriverResultSetType" ) ) ) ); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_MAX_ROW_SCAN, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MaxRowScan" ) ) ) ); |
| |
| // special settings for adabas |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_CONN_SHUTSERVICE, ::rtl::OUString::createFromAscii("ShutdownDatabase"))); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_CONN_DATAINC, ::rtl::OUString::createFromAscii("DataCacheSizeIncrement"))); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_CONN_CACHESIZE, ::rtl::OUString::createFromAscii("DataCacheSize"))); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_CONN_CTRLUSER, ::rtl::OUString::createFromAscii("ControlUser"))); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_CONN_CTRLPWD, ::rtl::OUString::createFromAscii("ControlPassword"))); |
| |
| // extra settings for odbc |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_USECATALOG, INFO_USECATALOG)); |
| // extra settings for a ldap address book |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_CONN_LDAP_BASEDN, INFO_CONN_LDAP_BASEDN)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_CONN_LDAP_ROWCOUNT, INFO_CONN_LDAP_ROWCOUNT)); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_CONN_LDAP_USESSL, ::rtl::OUString::createFromAscii("UseSSL"))); |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_DOCUMENT_URL, PROPERTY_URL)); |
| |
| // oracle |
| m_aIndirectPropTranslator.insert(MapInt2String::value_type(DSID_IGNORECURRENCY, ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("IgnoreCurrency")))); |
| |
| try |
| { |
| m_xDatabaseContext = Reference< XNameAccess >(m_xORB->createInstance(SERVICE_SDB_DATABASECONTEXT), UNO_QUERY); |
| m_xDynamicContext.set(m_xDatabaseContext,UNO_QUERY); |
| } |
| catch(Exception&) |
| { |
| } |
| |
| if ( !m_xDatabaseContext.is() ) |
| { |
| ShowServiceNotAvailableError(_pParent->GetParent(), String(SERVICE_SDB_DATABASECONTEXT), sal_True); |
| } |
| |
| DBG_ASSERT(m_xDynamicContext.is(), "ODbAdminDialog::ODbAdminDialog : no XNamingService interface !"); |
| } |
| //------------------------------------------------------------------------- |
| sal_Bool ODbDataSourceAdministrationHelper::getCurrentSettings(Sequence< PropertyValue >& _rDriverParam) |
| { |
| DBG_ASSERT(m_pItemSetHelper->getOutputSet(), "ODbDataSourceAdministrationHelper::getCurrentSettings : not to be called without an example set!"); |
| if (!m_pItemSetHelper->getOutputSet()) |
| return sal_False; |
| |
| ::std::vector< PropertyValue > aReturn; |
| // collecting this in a vector because it has a push_back, in opposite to sequences |
| |
| // user: DSID_USER -> "user" |
| SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pUser, SfxStringItem, DSID_USER, sal_True); |
| if (pUser && pUser->GetValue().Len()) |
| aReturn.push_back( |
| PropertyValue( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("user")), 0, |
| makeAny(::rtl::OUString(pUser->GetValue())), PropertyState_DIRECT_VALUE)); |
| |
| // check if the connection type requires a password |
| if (hasAuthentication(*m_pItemSetHelper->getOutputSet())) |
| { |
| // password: DSID_PASSWORD -> "password" |
| SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pPassword, SfxStringItem, DSID_PASSWORD, sal_True); |
| String sPassword = pPassword ? pPassword->GetValue() : String(); |
| SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pPasswordRequired, SfxBoolItem, DSID_PASSWORDREQUIRED, sal_True); |
| // if the set does not contain a password, but the item set says it requires one, ask the user |
| if ((!pPassword || !pPassword->GetValue().Len()) && (pPasswordRequired && pPasswordRequired->GetValue())) |
| { |
| SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pName, SfxStringItem, DSID_NAME, sal_True); |
| |
| Reference< XModel > xModel( getDataSourceOrModel( m_xDatasource ), UNO_QUERY_THROW ); |
| ::comphelper::NamedValueCollection aArgs( xModel->getArgs() ); |
| Reference< XInteractionHandler > xHandler( aArgs.getOrDefault( "InteractionHandler", Reference< XInteractionHandler >() ) ); |
| |
| if ( !xHandler.is() ) |
| { |
| // instantiate the default SDB interaction handler |
| xHandler = Reference< XInteractionHandler >( m_xORB->createInstance( SERVICE_TASK_INTERACTION_HANDLER ), UNO_QUERY ); |
| if ( !xHandler.is() ) |
| ShowServiceNotAvailableError(m_pParent->GetParent(), String(SERVICE_TASK_INTERACTION_HANDLER), sal_True); |
| } |
| |
| String sName = pName ? pName->GetValue() : String(); |
| String sLoginRequest(ModuleRes(STR_ENTER_CONNECTION_PASSWORD)); |
| ::rtl::OUString sTemp = sName; |
| sName = ::dbaui::getStrippedDatabaseName(NULL,sTemp); |
| if ( sName.Len() ) |
| sLoginRequest.SearchAndReplaceAscii("$name$", sName); |
| else |
| { |
| sLoginRequest.SearchAndReplaceAscii("\"$name$\"", String()); |
| sLoginRequest.SearchAndReplaceAscii("$name$", String()); // just to be sure that in other languages the string will be deleted |
| } |
| |
| // the request |
| AuthenticationRequest aRequest; |
| aRequest.ServerName = sName; |
| aRequest.Diagnostic = sLoginRequest; |
| aRequest.HasRealm = aRequest.HasAccount = sal_False; |
| // aRequest.Realm |
| aRequest.HasUserName = pUser != 0; |
| aRequest.UserName = pUser ? rtl::OUString(pUser->GetValue()) : ::rtl::OUString(); |
| aRequest.HasPassword = sal_True; |
| //aRequest.Password |
| aRequest.HasAccount = sal_False; |
| // aRequest.Account |
| |
| comphelper::OInteractionRequest* pRequest = new comphelper::OInteractionRequest(makeAny(aRequest)); |
| uno::Reference< XInteractionRequest > xRequest(pRequest); |
| |
| // build an interaction request |
| // two continuations (Ok and Cancel) |
| ::rtl::Reference< comphelper::OInteractionAbort > pAbort = new comphelper::OInteractionAbort; |
| ::rtl::Reference< dbaccess::OAuthenticationContinuation > pAuthenticate = new dbaccess::OAuthenticationContinuation; |
| pAuthenticate->setCanChangeUserName( sal_False ); |
| pAuthenticate->setRememberPassword( RememberAuthentication_SESSION ); |
| |
| // some knittings |
| pRequest->addContinuation(pAbort.get()); |
| pRequest->addContinuation(pAuthenticate.get()); |
| |
| // handle the request |
| try |
| { |
| ::vos::OGuard aSolarGuard(Application::GetSolarMutex()); |
| // release the mutex when calling the handler, it may need to lock the SolarMutex |
| xHandler->handle(xRequest); |
| } |
| catch(Exception&) |
| { |
| DBG_UNHANDLED_EXCEPTION(); |
| } |
| if (!pAuthenticate->wasSelected()) |
| return sal_False; |
| |
| sPassword = pAuthenticate->getPassword(); |
| if (pAuthenticate->getRememberPassword()) |
| m_pItemSetHelper->getWriteOutputSet()->Put(SfxStringItem(DSID_PASSWORD, sPassword)); |
| } |
| |
| if (sPassword.Len()) |
| aReturn.push_back( |
| PropertyValue( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("password")), 0, |
| makeAny(::rtl::OUString(sPassword)), PropertyState_DIRECT_VALUE)); |
| } |
| |
| if ( !aReturn.empty() ) |
| _rDriverParam = Sequence< PropertyValue >(&(*aReturn.begin()), aReturn.size()); |
| |
| // append all the other stuff (charset etc.) |
| fillDatasourceInfo(*m_pItemSetHelper->getOutputSet(), _rDriverParam); |
| |
| return sal_True; |
| } |
| //------------------------------------------------------------------------- |
| void ODbDataSourceAdministrationHelper::successfullyConnected() |
| { |
| DBG_ASSERT(m_pItemSetHelper->getOutputSet(), "ODbDataSourceAdministrationHelper::successfullyConnected: not to be called without an example set!"); |
| if (!m_pItemSetHelper->getOutputSet()) |
| return; |
| |
| if (hasAuthentication(*m_pItemSetHelper->getOutputSet())) |
| { |
| SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pPassword, SfxStringItem, DSID_PASSWORD, sal_True); |
| if (pPassword && (0 != pPassword->GetValue().Len())) |
| { |
| ::rtl::OUString sPassword = pPassword->GetValue(); |
| |
| Reference< XPropertySet > xCurrentDatasource = getCurrentDataSource(); |
| lcl_putProperty(xCurrentDatasource,m_aDirectPropTranslator[DSID_PASSWORD], makeAny(sPassword)); |
| } |
| } |
| } |
| //------------------------------------------------------------------------- |
| void ODbDataSourceAdministrationHelper::clearPassword() |
| { |
| if (m_pItemSetHelper->getWriteOutputSet()) |
| m_pItemSetHelper->getWriteOutputSet()->ClearItem(DSID_PASSWORD); |
| } |
| // ----------------------------------------------------------------------------- |
| ::std::pair< Reference<XConnection>,sal_Bool> ODbDataSourceAdministrationHelper::createConnection() |
| { |
| ::std::pair< Reference<XConnection>,sal_Bool> aRet; |
| aRet.second = sal_False; |
| Sequence< PropertyValue > aConnectionParams; |
| if ( getCurrentSettings(aConnectionParams) ) |
| { |
| // the current DSN |
| // fill the table list with this connection information |
| SQLExceptionInfo aErrorInfo; |
| try |
| { |
| WaitObject aWaitCursor(m_pParent); |
| aRet.first = getDriver()->connect(getConnectionURL(), aConnectionParams); |
| aRet.second = sal_True; |
| } |
| catch (SQLContext& e) { aErrorInfo = SQLExceptionInfo(e); } |
| catch (SQLWarning& e) { aErrorInfo = SQLExceptionInfo(e); } |
| catch (SQLException& e) { aErrorInfo = SQLExceptionInfo(e); } |
| |
| showError(aErrorInfo,m_pParent,getORB()); |
| } |
| if ( aRet.first.is() ) |
| successfullyConnected();// notify the admindlg to save the password |
| |
| return aRet; |
| } |
| // ----------------------------------------------------------------------------- |
| Reference< XDriver > ODbDataSourceAdministrationHelper::getDriver() |
| { |
| return getDriver(getConnectionURL()); |
| } |
| // ----------------------------------------------------------------------------- |
| Reference< XDriver > ODbDataSourceAdministrationHelper::getDriver(const ::rtl::OUString& _sURL) |
| { |
| // get the global DriverManager |
| Reference< XDriverAccess > xDriverManager; |
| String sCurrentActionError = String(ModuleRes(STR_COULDNOTCREATE_DRIVERMANAGER)); |
| // in case an error occures |
| sCurrentActionError.SearchAndReplaceAscii("#servicename#", (::rtl::OUString)SERVICE_SDBC_CONNECTIONPOOL); |
| try |
| { |
| xDriverManager = Reference< XDriverAccess >(getORB()->createInstance(SERVICE_SDBC_CONNECTIONPOOL), UNO_QUERY); |
| DBG_ASSERT(xDriverManager.is(), "ODbDataSourceAdministrationHelper::getDriver: could not instantiate the driver manager, or it does not provide the necessary interface!"); |
| } |
| catch (Exception& e) |
| { |
| // wrap the exception into an SQLException |
| SQLException aSQLWrapper(e.Message, getORB(), ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("S1000")), 0, Any()); |
| throw SQLException(sCurrentActionError, getORB(), ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("S1000")), 0, makeAny(aSQLWrapper)); |
| } |
| if (!xDriverManager.is()) |
| throw SQLException(sCurrentActionError, getORB(), ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("S1000")), 0, Any()); |
| |
| |
| Reference< XDriver > xDriver = xDriverManager->getDriverByURL(_sURL); |
| if (!xDriver.is()) |
| { |
| sCurrentActionError = String(ModuleRes(STR_NOREGISTEREDDRIVER)); |
| sCurrentActionError.SearchAndReplaceAscii("#connurl#", _sURL); |
| // will be caught and translated into an SQLContext exception |
| throw SQLException(sCurrentActionError, getORB(), ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("S1000")), 0, Any()); |
| } |
| return xDriver; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| Reference< XPropertySet > ODbDataSourceAdministrationHelper::getCurrentDataSource() |
| { |
| if ( !m_xDatasource.is() ) |
| { |
| Reference<XInterface> xIn(m_aDataSourceOrName,UNO_QUERY); |
| if ( !xIn.is() ) |
| { |
| ::rtl::OUString sCurrentDatasource; |
| m_aDataSourceOrName >>= sCurrentDatasource; |
| OSL_ENSURE(sCurrentDatasource.getLength(),"No datasource name given!"); |
| try |
| { |
| if ( m_xDatabaseContext.is() ) |
| m_xDatasource.set(m_xDatabaseContext->getByName(sCurrentDatasource),UNO_QUERY); |
| xIn = m_xDatasource; |
| } |
| catch(const Exception&) |
| { |
| } |
| } |
| m_xModel.set(getDataSourceOrModel(xIn),UNO_QUERY); |
| if ( m_xModel.is() ) |
| m_xDatasource.set(xIn,UNO_QUERY); |
| else |
| { |
| m_xDatasource.set(getDataSourceOrModel(xIn),UNO_QUERY); |
| m_xModel.set(xIn,UNO_QUERY); |
| } |
| } |
| |
| |
| DBG_ASSERT(m_xDatasource.is(), "ODbDataSourceAdministrationHelper::getCurrentDataSource: no data source!"); |
| return m_xDatasource; |
| } |
| //------------------------------------------------------------------------- |
| ::rtl::OUString ODbDataSourceAdministrationHelper::getDatasourceType( const SfxItemSet& _rSet ) |
| { |
| SFX_ITEMSET_GET( _rSet, pConnectURL, SfxStringItem, DSID_CONNECTURL, sal_True ); |
| DBG_ASSERT( pConnectURL , "ODbDataSourceAdministrationHelper::getDatasourceType: invalid items in the source set!" ); |
| SFX_ITEMSET_GET(_rSet, pTypeCollection, DbuTypeCollectionItem, DSID_TYPECOLLECTION, sal_True); |
| DBG_ASSERT(pTypeCollection, "ODbDataSourceAdministrationHelper::getDatasourceType: invalid items in the source set!"); |
| ::dbaccess::ODsnTypeCollection* pCollection = pTypeCollection->getCollection(); |
| return pCollection->getType(pConnectURL->GetValue()); |
| } |
| |
| //------------------------------------------------------------------------- |
| sal_Bool ODbDataSourceAdministrationHelper::hasAuthentication(const SfxItemSet& _rSet) const |
| { |
| return DataSourceMetaData::getAuthentication( getDatasourceType( _rSet ) ) != AuthNone; |
| } |
| // ----------------------------------------------------------------------------- |
| String ODbDataSourceAdministrationHelper::getConnectionURL() const |
| { |
| String sNewUrl; |
| |
| ::rtl::OUString eType = getDatasourceType(*m_pItemSetHelper->getOutputSet()); |
| |
| SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pUrlItem, SfxStringItem, DSID_CONNECTURL, sal_True); |
| SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pTypeCollection, DbuTypeCollectionItem, DSID_TYPECOLLECTION, sal_True); |
| |
| OSL_ENSURE(pUrlItem,"Connection URL is NULL. -> GPF!"); |
| DBG_ASSERT(pTypeCollection, "ODbDataSourceAdministrationHelper::getDatasourceType: invalid items in the source set!"); |
| ::dbaccess::ODsnTypeCollection* pCollection = pTypeCollection->getCollection(); |
| DBG_ASSERT(pCollection, "ODbDataSourceAdministrationHelper::getDatasourceType: invalid type collection!"); |
| |
| switch( pCollection->determineType(eType) ) |
| { |
| case ::dbaccess::DST_DBASE: |
| case ::dbaccess::DST_FLAT: |
| case ::dbaccess::DST_CALC: |
| break; |
| case ::dbaccess::DST_ADABAS: |
| { |
| SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pHostName, SfxStringItem, DSID_CONN_HOSTNAME, sal_True); |
| sNewUrl = lcl_createHostWithPort(pHostName,NULL); |
| String sUrl = pCollection->cutPrefix(pUrlItem->GetValue()); |
| if ( sUrl.GetTokenCount(':') == 1 ) |
| sNewUrl += String::CreateFromAscii(":"); |
| |
| sNewUrl += sUrl; |
| } |
| break; |
| case ::dbaccess::DST_MSACCESS: |
| case ::dbaccess::DST_MSACCESS_2007: |
| { |
| ::rtl::OUString sFileName = pCollection->cutPrefix(pUrlItem->GetValue()); |
| ::rtl::OUString sNewFileName; |
| if ( ::osl::FileBase::getSystemPathFromFileURL( sFileName, sNewFileName ) == ::osl::FileBase::E_None ) |
| { |
| sNewUrl += String(sNewFileName); |
| } |
| } |
| break; |
| case ::dbaccess::DST_MYSQL_NATIVE: |
| case ::dbaccess::DST_MYSQL_JDBC: |
| { |
| SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pHostName, SfxStringItem, DSID_CONN_HOSTNAME, sal_True); |
| SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pPortNumber, SfxInt32Item, DSID_MYSQL_PORTNUMBER, sal_True); |
| SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pDatabaseName, SfxStringItem, DSID_DATABASENAME, sal_True); |
| sNewUrl = lcl_createHostWithPort(pHostName,pPortNumber); |
| String sDatabaseName = pDatabaseName ? pDatabaseName->GetValue() : String(); |
| if ( !sDatabaseName.Len() && pUrlItem ) |
| sDatabaseName = pCollection->cutPrefix( pUrlItem->GetValue() ); |
| // TODO: what's that? Why is the database name transported via the URL Item? |
| // Huh? Anybody there? |
| // OJ: It is needed when the connection properties are changed. There the URL is used for every type. |
| |
| if ( sDatabaseName.Len() ) |
| { |
| sNewUrl += String::CreateFromAscii("/"); |
| sNewUrl += sDatabaseName; |
| } |
| } |
| break; |
| case ::dbaccess::DST_ORACLE_JDBC: |
| { |
| SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pHostName, SfxStringItem, DSID_CONN_HOSTNAME, sal_True); |
| SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pPortNumber, SfxInt32Item, DSID_ORACLE_PORTNUMBER, sal_True); |
| SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pDatabaseName, SfxStringItem, DSID_DATABASENAME, sal_True); |
| if ( pHostName && pHostName->GetValue().Len() ) |
| { |
| sNewUrl = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("@")); |
| sNewUrl += lcl_createHostWithPort(pHostName,pPortNumber); |
| String sDatabaseName = pDatabaseName ? pDatabaseName->GetValue() : String(); |
| if ( !sDatabaseName.Len() && pUrlItem ) |
| sDatabaseName = pCollection->cutPrefix( pUrlItem->GetValue() ); |
| if ( sDatabaseName.Len() ) |
| { |
| sNewUrl += String::CreateFromAscii(":"); |
| sNewUrl += sDatabaseName; |
| } |
| } |
| else |
| { // here someone entered a JDBC url which looks like oracle, so we have to use the url property |
| |
| } |
| } |
| break; |
| case ::dbaccess::DST_LDAP: |
| { |
| // SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pHostName, SfxStringItem, DSID_CONN_HOSTNAME, sal_True); |
| SFX_ITEMSET_GET(*m_pItemSetHelper->getOutputSet(), pPortNumber, SfxInt32Item, DSID_CONN_LDAP_PORTNUMBER, sal_True); |
| sNewUrl = pCollection->cutPrefix(pUrlItem->GetValue()); |
| sNewUrl += lcl_createHostWithPort(NULL,pPortNumber); |
| } |
| break; |
| case ::dbaccess::DST_JDBC: |
| // run through |
| default: |
| break; |
| } |
| if ( sNewUrl.Len() ) |
| { |
| String sUrl = pCollection->getPrefix(eType); |
| sUrl += sNewUrl; |
| sNewUrl = sUrl; |
| } |
| else |
| sNewUrl = pUrlItem->GetValue(); |
| |
| return sNewUrl; |
| } |
| //------------------------------------------------------------------------- |
| struct PropertyValueLess |
| { |
| bool operator() (const PropertyValue& x, const PropertyValue& y) const |
| { return x.Name < y.Name ? true : false; } // construct prevents a MSVC6 warning |
| }; |
| DECLARE_STL_SET( PropertyValue, PropertyValueLess, PropertyValueSet); |
| |
| //........................................................................ |
| void ODbDataSourceAdministrationHelper::translateProperties(const Reference< XPropertySet >& _rxSource, SfxItemSet& _rDest) |
| { |
| ::rtl::OUString sNewConnectURL, sName, sUid, sPwd; |
| Sequence< ::rtl::OUString > aTableFitler; |
| |
| if (_rxSource.is()) |
| { |
| for ( ConstMapInt2StringIterator aDirect = m_aDirectPropTranslator.begin(); |
| aDirect != m_aDirectPropTranslator.end(); |
| ++aDirect |
| ) |
| { |
| // get the property value |
| Any aValue; |
| try |
| { |
| aValue = _rxSource->getPropertyValue(aDirect->second); |
| } |
| catch(Exception&) |
| { |
| #ifdef DBG_UTIL |
| ::rtl::OString aMessage("ODbDataSourceAdministrationHelper::translateProperties: could not extract the property "); |
| aMessage += ::rtl::OString(aDirect->second.getStr(), aDirect->second.getLength(), RTL_TEXTENCODING_ASCII_US); |
| aMessage += ::rtl::OString("!"); |
| DBG_ERROR(aMessage.getStr()); |
| #endif |
| } |
| // transfer it into an item |
| implTranslateProperty(_rDest, aDirect->first, aValue); |
| } |
| |
| // get the additional informations |
| Sequence< PropertyValue > aAdditionalInfo; |
| try |
| { |
| _rxSource->getPropertyValue(PROPERTY_INFO) >>= aAdditionalInfo; |
| } |
| catch(Exception&) { } |
| |
| // collect the names of the additional settings |
| const PropertyValue* pAdditionalInfo = aAdditionalInfo.getConstArray(); |
| PropertyValueSet aInfos; |
| for (sal_Int32 i=0; i<aAdditionalInfo.getLength(); ++i, ++pAdditionalInfo) |
| { |
| if (0 == pAdditionalInfo->Name.compareToAscii("JDBCDRV")) |
| { // compatibility |
| PropertyValue aCompatibility(*pAdditionalInfo); |
| aCompatibility.Name = ::rtl::OUString::createFromAscii("JavaDriverClass"); |
| aInfos.insert(aCompatibility); |
| } |
| else |
| aInfos.insert(*pAdditionalInfo); |
| } |
| |
| // go through all known translations and check if we have such a setting |
| if ( !aInfos.empty() ) |
| { |
| PropertyValue aSearchFor; |
| ConstMapInt2StringIterator aEnd = m_aIndirectPropTranslator.end(); |
| for ( ConstMapInt2StringIterator aIndirect = m_aIndirectPropTranslator.begin(); |
| aIndirect != aEnd; |
| ++aIndirect) |
| { |
| aSearchFor.Name = aIndirect->second; |
| ConstPropertyValueSetIterator aInfoPos = aInfos.find(aSearchFor); |
| if (aInfos.end() != aInfoPos) |
| // the property is contained in the info sequence |
| // -> transfer it into an item |
| implTranslateProperty(_rDest, aIndirect->first, aInfoPos->Value); |
| } |
| } |
| |
| convertUrl(_rDest); |
| } |
| |
| try |
| { |
| _rDest.Put(OPropertySetItem(DSID_DATASOURCE_UNO, _rxSource)); |
| Reference<XStorable> xStore(getDataSourceOrModel(_rxSource),UNO_QUERY); |
| _rDest.Put(SfxBoolItem(DSID_READONLY, !xStore.is() || xStore->isReadonly() )); |
| } |
| catch(Exception&) |
| { |
| OSL_ENSURE(0,"IsReadOnly throws an exception!"); |
| } |
| } |
| |
| //------------------------------------------------------------------------- |
| void ODbDataSourceAdministrationHelper::translateProperties(const SfxItemSet& _rSource, const Reference< XPropertySet >& _rxDest) |
| { |
| DBG_ASSERT(_rxDest.is(), "ODbDataSourceAdministrationHelper::translateProperties: invalid property set!"); |
| if (!_rxDest.is()) |
| return; |
| |
| // the property set info |
| Reference< XPropertySetInfo > xInfo; |
| try { xInfo = _rxDest->getPropertySetInfo(); } |
| catch(Exception&) { } |
| |
| const ::rtl::OUString sUrlProp(RTL_CONSTASCII_USTRINGPARAM("URL")); |
| // ----------------------------- |
| // transfer the direct properties |
| for ( ConstMapInt2StringIterator aDirect = m_aDirectPropTranslator.begin(); |
| aDirect != m_aDirectPropTranslator.end(); |
| ++aDirect |
| ) |
| { |
| const SfxPoolItem* pCurrentItem = _rSource.GetItem((sal_uInt16)aDirect->first); |
| if (pCurrentItem) |
| { |
| sal_Int16 nAttributes = PropertyAttribute::READONLY; |
| if (xInfo.is()) |
| { |
| try { nAttributes = xInfo->getPropertyByName(aDirect->second).Attributes; } |
| catch(Exception&) { } |
| } |
| if ((nAttributes & PropertyAttribute::READONLY) == 0) |
| { |
| if ( sUrlProp == aDirect->second ) |
| { |
| Any aValue(makeAny(::rtl::OUString(getConnectionURL()))); |
| // aValue <<= ::rtl::OUString(); |
| lcl_putProperty(_rxDest, aDirect->second,aValue); |
| } |
| else |
| implTranslateProperty(_rxDest, aDirect->second, pCurrentItem); |
| } |
| } |
| } |
| |
| // ------------------------------- |
| // now for the indirect properties |
| |
| Sequence< PropertyValue > aInfo; |
| // the original properties |
| try |
| { |
| _rxDest->getPropertyValue(PROPERTY_INFO) >>= aInfo; |
| } |
| catch(Exception&) { } |
| |
| // overwrite and extend them |
| fillDatasourceInfo(_rSource, aInfo); |
| // and propagate the (newly composed) sequence to the set |
| lcl_putProperty(_rxDest,PROPERTY_INFO, makeAny(aInfo)); |
| } |
| |
| |
| //------------------------------------------------------------------------- |
| void ODbDataSourceAdministrationHelper::fillDatasourceInfo(const SfxItemSet& _rSource, Sequence< ::com::sun::star::beans::PropertyValue >& _rInfo) |
| { |
| // within the current "Info" sequence, replace the ones we can examine from the item set |
| // (we don't just fill a completely new sequence with our own items, but we preserve any properties unknown to |
| // us) |
| |
| // first determine which of all the items are relevant for the data source (depends on the connection url) |
| ::rtl::OUString eType = getDatasourceType(_rSource); |
| ::std::vector< sal_Int32> aDetailIds; |
| ODriversSettings::getSupportedIndirectSettings(eType,getORB(),aDetailIds); |
| |
| // collect the translated property values for the relevant items |
| PropertyValueSet aRelevantSettings; |
| ConstMapInt2StringIterator aTranslation; |
| ::std::vector< sal_Int32>::iterator aDetailsEnd = aDetailIds.end(); |
| for (::std::vector< sal_Int32>::iterator aIter = aDetailIds.begin();aIter != aDetailsEnd ; ++aIter) |
| { |
| const SfxPoolItem* pCurrent = _rSource.GetItem((sal_uInt16)*aIter); |
| aTranslation = m_aIndirectPropTranslator.find(*aIter); |
| if ( pCurrent && (m_aIndirectPropTranslator.end() != aTranslation) ) |
| { |
| if ( aTranslation->second == INFO_CHARSET ) |
| { |
| ::rtl::OUString sCharSet; |
| implTranslateProperty(pCurrent) >>= sCharSet; |
| if ( sCharSet.getLength() ) |
| aRelevantSettings.insert(PropertyValue(aTranslation->second, 0, makeAny(sCharSet), PropertyState_DIRECT_VALUE)); |
| } |
| else |
| aRelevantSettings.insert(PropertyValue(aTranslation->second, 0, implTranslateProperty(pCurrent), PropertyState_DIRECT_VALUE)); |
| } |
| } |
| |
| // settings to preserve |
| MapInt2String aPreservedSettings; |
| |
| // now aRelevantSettings contains all the property values relevant for the current data source type, |
| // check the original sequence if it already contains any of these values (which have to be overwritten, then) |
| PropertyValue* pInfo = _rInfo.getArray(); |
| PropertyValue aSearchFor; |
| sal_Int32 nObsoleteSetting = -1; |
| sal_Int32 nCount = _rInfo.getLength(); |
| for (sal_Int32 i = 0; i < nCount; ++i, ++pInfo) |
| { |
| aSearchFor.Name = pInfo->Name; |
| PropertyValueSetIterator aOverwrittenSetting = aRelevantSettings.find(aSearchFor); |
| if (aRelevantSettings.end() != aOverwrittenSetting) |
| { // the setting was present in the original sequence, and it is to be overwritten -> replace it |
| if ( !::comphelper::compare(pInfo->Value,aOverwrittenSetting->Value) ) |
| *pInfo = *aOverwrittenSetting; |
| aRelevantSettings.erase(aOverwrittenSetting); |
| } |
| else if (0 == pInfo->Name.compareToAscii("JDBCDRV")) |
| { // this is a compatibility setting, remove it from the sequence (it's replaced by JavaDriverClass) |
| nObsoleteSetting = i; |
| } |
| else |
| aPreservedSettings[i] = pInfo->Name; |
| } |
| if (-1 != nObsoleteSetting) |
| ::comphelper::removeElementAt(_rInfo, nObsoleteSetting); |
| |
| if ( !aPreservedSettings.empty() ) |
| { // check if there are settings which |
| // * are known as indirect properties |
| // * but not relevant for the current data source type |
| // These settings have to be removed: If they're not relevant, we have no UI for changing them. |
| // 25.06.2001 - 88004/87182 - frank.schoenheit@sun.com |
| |
| // for this, we need a string-controlled quick access to m_aIndirectPropTranslator |
| StringSet aIndirectProps; |
| ::std::transform(m_aIndirectPropTranslator.begin(), |
| m_aIndirectPropTranslator.end(), |
| ::std::insert_iterator<StringSet>(aIndirectProps,aIndirectProps.begin()), |
| ::std::select2nd<MapInt2String::value_type>()); |
| |
| // now check the to-be-preserved props |
| ::std::vector< sal_Int32 > aRemoveIndexes; |
| sal_Int32 nPositionCorrector = 0; |
| ConstMapInt2StringIterator aPreservedEnd = aPreservedSettings.end(); |
| for ( ConstMapInt2StringIterator aPreserved = aPreservedSettings.begin(); |
| aPreserved != aPreservedEnd; |
| ++aPreserved |
| ) |
| { |
| if (aIndirectProps.end() != aIndirectProps.find(aPreserved->second)) |
| { |
| #ifdef DBG_UTIL |
| const ::rtl::OUString sName = aPreserved->second; |
| #endif |
| aRemoveIndexes.push_back(aPreserved->first - nPositionCorrector); |
| ++nPositionCorrector; |
| } |
| } |
| // now finally remove all such props |
| ::std::vector< sal_Int32 >::const_iterator aRemoveEnd = aRemoveIndexes.end(); |
| for ( ::std::vector< sal_Int32 >::const_iterator aRemoveIndex = aRemoveIndexes.begin(); |
| aRemoveIndex != aRemoveEnd; |
| ++aRemoveIndex |
| ) |
| ::comphelper::removeElementAt(_rInfo, *aRemoveIndex); |
| #ifdef DBG_UTIL |
| const PropertyValue* pWhatsLeft = _rInfo.getConstArray(); |
| const PropertyValue* pWhatsLeftEnd = pWhatsLeft + _rInfo.getLength(); |
| for (; pWhatsLeft != pWhatsLeftEnd; ++pWhatsLeft) |
| { |
| ::rtl::OUString sLookAtIt = pWhatsLeft->Name; |
| } |
| #endif |
| } |
| |
| ::connectivity::DriversConfig aDriverConfig(getORB()); |
| const ::comphelper::NamedValueCollection& aProperties = aDriverConfig.getProperties(eType); |
| Sequence< Any> aTypeSettings; |
| aTypeSettings = aProperties.getOrDefault("TypeInfoSettings",aTypeSettings); |
| // here we have a special entry for types from oracle |
| if ( aTypeSettings.getLength() ) |
| { |
| aRelevantSettings.insert(PropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TypeInfoSettings")), 0, makeAny(aTypeSettings), PropertyState_DIRECT_VALUE)); |
| } |
| |
| // check which values are still left ('cause they were not present in the original sequence, but are to be set) |
| if ( !aRelevantSettings.empty() ) |
| { |
| sal_Int32 nOldLength = _rInfo.getLength(); |
| _rInfo.realloc(nOldLength + aRelevantSettings.size()); |
| PropertyValue* pAppendValues = _rInfo.getArray() + nOldLength; |
| ConstPropertyValueSetIterator aRelevantEnd = aRelevantSettings.end(); |
| for ( ConstPropertyValueSetIterator aLoop = aRelevantSettings.begin(); |
| aLoop != aRelevantEnd; |
| ++aLoop, ++pAppendValues |
| ) |
| { |
| if ( aLoop->Name == INFO_CHARSET ) |
| { |
| ::rtl::OUString sCharSet; |
| aLoop->Value >>= sCharSet; |
| if ( sCharSet.getLength() ) |
| *pAppendValues = *aLoop; |
| } |
| else |
| *pAppendValues = *aLoop; |
| } |
| } |
| } |
| //------------------------------------------------------------------------- |
| Any ODbDataSourceAdministrationHelper::implTranslateProperty(const SfxPoolItem* _pItem) |
| { |
| // translate the SfxPoolItem |
| Any aValue; |
| |
| const SfxStringItem* pStringItem = PTR_CAST( SfxStringItem, _pItem ); |
| const SfxBoolItem* pBoolItem = PTR_CAST( SfxBoolItem, _pItem ); |
| const OptionalBoolItem* pOptBoolItem = PTR_CAST( OptionalBoolItem, _pItem ); |
| const SfxInt32Item* pInt32Item = PTR_CAST( SfxInt32Item, _pItem ); |
| const OStringListItem* pStringListItem = PTR_CAST( OStringListItem, _pItem ); |
| |
| if ( pStringItem ) |
| { |
| aValue <<= ::rtl::OUString( pStringItem->GetValue().GetBuffer() ); |
| } |
| else if ( pBoolItem ) |
| { |
| aValue <<= pBoolItem->GetValue(); |
| } |
| else if ( pOptBoolItem ) |
| { |
| if ( !pOptBoolItem->HasValue() ) |
| aValue.clear(); |
| else |
| aValue <<= (sal_Bool)pOptBoolItem->GetValue(); |
| } |
| else if ( pInt32Item ) |
| { |
| aValue <<= pInt32Item->GetValue(); |
| } |
| else if ( pStringListItem ) |
| { |
| aValue <<= pStringListItem->getList(); |
| } |
| else |
| { |
| DBG_ERROR("ODbDataSourceAdministrationHelper::implTranslateProperty: unsupported item type!"); |
| return aValue; |
| } |
| |
| return aValue; |
| } |
| //------------------------------------------------------------------------- |
| void ODbDataSourceAdministrationHelper::implTranslateProperty(const Reference< XPropertySet >& _rxSet, const ::rtl::OUString& _rName, const SfxPoolItem* _pItem) |
| { |
| Any aValue = implTranslateProperty(_pItem); |
| lcl_putProperty(_rxSet, _rName,aValue); |
| } |
| #ifdef DBG_UTIL |
| //------------------------------------------------------------------------- |
| ::rtl::OString ODbDataSourceAdministrationHelper::translatePropertyId( sal_Int32 _nId ) |
| { |
| ::rtl::OUString aString; |
| |
| MapInt2String::const_iterator aPos = m_aDirectPropTranslator.find( _nId ); |
| if ( m_aDirectPropTranslator.end() != aPos ) |
| { |
| aString = aPos->second; |
| } |
| else |
| { |
| MapInt2String::const_iterator indirectPos = m_aIndirectPropTranslator.find( _nId ); |
| if ( m_aIndirectPropTranslator.end() != indirectPos ) |
| aString = indirectPos->second; |
| } |
| |
| ::rtl::OString aReturn( aString.getStr(), aString.getLength(), RTL_TEXTENCODING_ASCII_US ); |
| return aReturn; |
| } |
| #endif |
| |
| //------------------------------------------------------------------------- |
| void ODbDataSourceAdministrationHelper::implTranslateProperty( SfxItemSet& _rSet, sal_Int32 _nId, const Any& _rValue ) |
| { |
| switch ( _rValue.getValueType().getTypeClass() ) |
| { |
| case TypeClass_STRING: |
| if ( implCheckItemType( _rSet, _nId, SfxStringItem::StaticType() ) ) |
| { |
| ::rtl::OUString sValue; |
| _rValue >>= sValue; |
| _rSet.Put(SfxStringItem(_nId, sValue.getStr())); |
| } |
| else { |
| DBG_ERROR( |
| ( ::rtl::OString( "ODbDataSourceAdministrationHelper::implTranslateProperty: invalid property value (" ) |
| += ::rtl::OString( translatePropertyId( _nId ) ) |
| += ::rtl::OString( " should be no string)!" ) |
| ).getStr() |
| ); |
| } |
| break; |
| |
| case TypeClass_BOOLEAN: |
| if ( implCheckItemType( _rSet, _nId, SfxBoolItem::StaticType() ) ) |
| { |
| sal_Bool bVal = sal_False; |
| _rValue >>= bVal; |
| _rSet.Put(SfxBoolItem(_nId, bVal)); |
| } |
| else if ( implCheckItemType( _rSet, _nId, OptionalBoolItem::StaticType() ) ) |
| { |
| OptionalBoolItem aItem( _nId ); |
| if ( _rValue.hasValue() ) |
| { |
| sal_Bool bValue = sal_False; |
| _rValue >>= bValue; |
| aItem.SetValue( bValue ); |
| } |
| else |
| aItem.ClearValue(); |
| _rSet.Put( aItem ); |
| } |
| else { |
| DBG_ERROR( |
| ( ::rtl::OString( "ODbDataSourceAdministrationHelper::implTranslateProperty: invalid property value (" ) |
| += ::rtl::OString( translatePropertyId( _nId ) ) |
| += ::rtl::OString( " should be no boolean)!" ) |
| ).getStr() |
| ); |
| } |
| break; |
| |
| case TypeClass_LONG: |
| if ( implCheckItemType( _rSet, _nId, SfxInt32Item::StaticType() ) ) |
| { |
| sal_Int32 nValue = 0; |
| _rValue >>= nValue; |
| _rSet.Put( SfxInt32Item( _nId, nValue ) ); |
| } |
| else { |
| DBG_ERROR( |
| ( ::rtl::OString( "ODbDataSourceAdministrationHelper::implTranslateProperty: invalid property value (" ) |
| += ::rtl::OString( translatePropertyId( _nId ) ) |
| += ::rtl::OString( " should be no int)!" ) |
| ).getStr() |
| ); |
| } |
| break; |
| |
| case TypeClass_SEQUENCE: |
| if ( implCheckItemType( _rSet, _nId, OStringListItem::StaticType() ) ) |
| { |
| // determine the element type |
| TypeDescription aTD(_rValue.getValueType()); |
| typelib_IndirectTypeDescription* pSequenceTD = |
| reinterpret_cast< typelib_IndirectTypeDescription* >(aTD.get()); |
| DBG_ASSERT(pSequenceTD && pSequenceTD->pType, "ODbDataSourceAdministrationHelper::implTranslateProperty: invalid sequence type!"); |
| |
| Type aElementType(pSequenceTD->pType); |
| switch (aElementType.getTypeClass()) |
| { |
| case TypeClass_STRING: |
| { |
| Sequence< ::rtl::OUString > aStringList; |
| _rValue >>= aStringList; |
| _rSet.Put(OStringListItem(_nId, aStringList)); |
| } |
| break; |
| default: |
| DBG_ERROR("ODbDataSourceAdministrationHelper::implTranslateProperty: unsupported property value type!"); |
| } |
| } |
| else { |
| DBG_ERROR( |
| ( ::rtl::OString( "ODbDataSourceAdministrationHelper::implTranslateProperty: invalid property value (" ) |
| += ::rtl::OString( translatePropertyId( _nId ) ) |
| += ::rtl::OString( " should be no string sequence)!" ) |
| ).getStr() |
| ); |
| } |
| break; |
| |
| case TypeClass_VOID: |
| _rSet.ClearItem(_nId); |
| break; |
| |
| default: |
| DBG_ERROR("ODbDataSourceAdministrationHelper::implTranslateProperty: unsupported property value type!"); |
| } |
| } |
| |
| |
| String ODbDataSourceAdministrationHelper::getDocumentUrl(SfxItemSet& _rDest) |
| { |
| SFX_ITEMSET_GET(_rDest, pUrlItem, SfxStringItem, DSID_DOCUMENT_URL, sal_True); |
| OSL_ENSURE(pUrlItem,"Document URL is NULL. -> GPF!"); |
| return pUrlItem->GetValue(); |
| } |
| |
| |
| // ----------------------------------------------------------------------------- |
| void ODbDataSourceAdministrationHelper::convertUrl(SfxItemSet& _rDest) |
| { |
| ::rtl::OUString eType = getDatasourceType(_rDest); |
| |
| SFX_ITEMSET_GET(_rDest, pUrlItem, SfxStringItem, DSID_CONNECTURL, sal_True); |
| SFX_ITEMSET_GET(_rDest, pTypeCollection, DbuTypeCollectionItem, DSID_TYPECOLLECTION, sal_True); |
| |
| OSL_ENSURE(pUrlItem,"Connection URL is NULL. -> GPF!"); |
| DBG_ASSERT(pTypeCollection, "ODbAdminDialog::getDatasourceType: invalid items in the source set!"); |
| ::dbaccess::ODsnTypeCollection* pCollection = pTypeCollection->getCollection(); |
| DBG_ASSERT(pCollection, "ODbAdminDialog::getDatasourceType: invalid type collection!"); |
| |
| sal_uInt16 nPortNumberId = 0; |
| sal_Int32 nPortNumber = -1; |
| String sNewHostName; |
| //String sUrl = pCollection->cutPrefix(pUrlItem->GetValue()); |
| String sUrlPart; |
| |
| pCollection->extractHostNamePort(pUrlItem->GetValue(),sUrlPart,sNewHostName,nPortNumber); |
| const ::dbaccess::DATASOURCE_TYPE eTy = pCollection->determineType(eType); |
| |
| switch( eTy ) |
| { |
| case ::dbaccess::DST_MYSQL_NATIVE: |
| case ::dbaccess::DST_MYSQL_JDBC: |
| nPortNumberId = DSID_MYSQL_PORTNUMBER; |
| break; |
| case ::dbaccess::DST_ORACLE_JDBC: |
| nPortNumberId = DSID_ORACLE_PORTNUMBER; |
| break; |
| case ::dbaccess::DST_LDAP: |
| nPortNumberId = DSID_CONN_LDAP_PORTNUMBER; |
| break; |
| default: |
| break; |
| } |
| |
| if ( sUrlPart.Len() ) |
| { |
| if ( eTy == ::dbaccess::DST_MYSQL_NATIVE ) |
| { |
| _rDest.Put( SfxStringItem( DSID_DATABASENAME, sUrlPart ) ); |
| } |
| else |
| { |
| String sNewUrl = pCollection->getPrefix(eType); |
| sNewUrl += sUrlPart; |
| _rDest.Put( SfxStringItem( DSID_CONNECTURL, sNewUrl ) ); |
| } |
| } |
| |
| if ( sNewHostName.Len() ) |
| _rDest.Put(SfxStringItem(DSID_CONN_HOSTNAME, sNewHostName)); |
| |
| if ( nPortNumber != -1 && nPortNumberId != 0 ) |
| _rDest.Put(SfxInt32Item(nPortNumberId, nPortNumber)); |
| |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool ODbDataSourceAdministrationHelper::saveChanges(const SfxItemSet& _rSource) |
| { |
| // put the remembered settings into the property set |
| Reference<XPropertySet> xDatasource = getCurrentDataSource(); |
| if ( !xDatasource.is() ) |
| return sal_False; |
| |
| translateProperties(_rSource,xDatasource ); |
| |
| return sal_True; |
| } |
| // ----------------------------------------------------------------------------- |
| void ODbDataSourceAdministrationHelper::setDataSourceOrName( const Any& _rDataSourceOrName ) |
| { |
| DBG_ASSERT( !m_aDataSourceOrName.hasValue(), "ODbDataSourceAdministrationHelper::setDataSourceOrName: already have one!" ); |
| // hmm. We could reset m_xDatasource/m_xModel, probably, and continue working |
| m_aDataSourceOrName = _rDataSourceOrName; |
| } |
| //========================================================================= |
| //= DbuTypeCollectionItem |
| //========================================================================= |
| TYPEINIT1(DbuTypeCollectionItem, SfxPoolItem); |
| //------------------------------------------------------------------------- |
| DbuTypeCollectionItem::DbuTypeCollectionItem(sal_Int16 _nWhich, ::dbaccess::ODsnTypeCollection* _pCollection) |
| :SfxPoolItem(_nWhich) |
| ,m_pCollection(_pCollection) |
| { |
| } |
| |
| //------------------------------------------------------------------------- |
| DbuTypeCollectionItem::DbuTypeCollectionItem(const DbuTypeCollectionItem& _rSource) |
| :SfxPoolItem(_rSource) |
| ,m_pCollection(_rSource.getCollection()) |
| { |
| } |
| |
| //------------------------------------------------------------------------- |
| int DbuTypeCollectionItem::operator==(const SfxPoolItem& _rItem) const |
| { |
| DbuTypeCollectionItem* pCompare = PTR_CAST(DbuTypeCollectionItem, &_rItem); |
| return pCompare && (pCompare->getCollection() == getCollection()); |
| } |
| |
| //------------------------------------------------------------------------- |
| SfxPoolItem* DbuTypeCollectionItem::Clone(SfxItemPool* /*_pPool*/) const |
| { |
| return new DbuTypeCollectionItem(*this); |
| } |
| |
| //......................................................................... |
| } // namespace dbaui |
| //......................................................................... |
| |
| |
| |