dbmgr.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   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 .
 */
#ifndef INCLUDED_SW_INC_DBMGR_HXX
#define INCLUDED_SW_INC_DBMGR_HXX
 
#include <rtl/ustring.hxx>
#include <tools/solar.h>
#include <tools/long.hxx>
#include <i18nlangtag/lang.h>
#include <com/sun/star/util/Date.hpp>
#include "swdllapi.h"
#include "swdbdata.hxx"
#include <com/sun/star/uno/Reference.h>
#include <com/sun/star/uno/Sequence.hxx>
#include <com/sun/star/lang/Locale.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
 
#include <memory>
#include <vector>
 
namespace com::sun::star{
    namespace sdbc{
        class XConnection;
        class XStatement;
        class XDataSource;
        class XResultSet;
    }
    namespace beans{
 
        class XPropertySet;
    }
    namespace sdbcx{
        class XColumnsSupplier;
    }
    namespace util{
        class XNumberFormatter;
    }
    namespace mail{
        class XSmtpService;
    }
    namespace embed { class XStorage; }
    namespace frame { class XStorable; }
}
namespace svx {
    class ODataAccessDescriptor;
}
 
struct SwDBFormatData
{
    css::util::Date aNullDate;
    css::uno::Reference< css::util::XNumberFormatter> xFormatter;
    css::lang::Locale aLocale;
};
 
namespace weld {
    class ComboBox;
    class Window;
}
 
class SwView;
class SwWrtShell;
class ListBox;
class SvNumberFormatter;
class SwXMailMerge;
class SwMailMergeConfigItem;
class SwCalc;
class INetURLObject;
class SwDocShell;
 
enum DBManagerOptions
{
    DBMGR_MERGE,             
    DBMGR_MERGE_PRINTER,     
    DBMGR_MERGE_EMAIL,       
    DBMGR_MERGE_FILE,        
    DBMGR_MERGE_SHELL        
};
 
// Administration of (new) logical databases.
enum class SwDBSelect
{
    UNKNOWN, TABLE, QUERY
};
 
struct SwDSParam : public SwDBData
{
    css::util::Date  aNullDate;
 
    css::uno::Reference<css::util::XNumberFormatter>    xFormatter;
    css::uno::Reference< css::sdbc::XConnection>       xConnection;
    css::uno::Reference< css::sdbc::XStatement>        xStatement;
    css::uno::Reference< css::sdbc::XResultSet>        xResultSet;
    css::uno::Sequence<  css::uno::Any >               aSelection;
    bool bScrollable;
    bool bEndOfDB;
    tools::Long nSelectionIndex;
 
    SwDSParam(const SwDBData& rData) :
        SwDBData(rData),
        bScrollable(false),
        bEndOfDB(false),
        nSelectionIndex(0)
        {}
 
    SwDSParam(const SwDBData& rData,
        const css::uno::Reference< css::sdbc::XResultSet>&    xResSet,
        const css::uno::Sequence<  css::uno::Any >&   rSelection) :
        SwDBData(rData),
        xResultSet(xResSet),
        aSelection(rSelection),
        bScrollable(true),
        bEndOfDB(false),
        nSelectionIndex(0)
        {}
 
    bool HasValidRecord() const
        { return( !bEndOfDB && xResultSet.is() ); }
};
 
typedef std::vector<std::unique_ptr<SwDSParam>> SwDSParams_t;
 
struct SwMergeDescriptor
{
    const DBManagerOptions                              nMergeType;
    SwWrtShell&                                         rSh;
    const svx::ODataAccessDescriptor&                   rDescriptor;
 
    bool                                                bCreateSingleFile;
 
    OUString                                            sSaveToFilter;
    OUString                                            sSaveToFilterOptions;
    css::uno::Sequence< css::beans::PropertyValue >     aSaveToFilterData;
    OUString                                            sPrefix;
    bool                                                bPrefixIsFilename;
    OUString                                            sSubject;
    OUString                                            sMailBody;
    OUString                                            sAttachmentName;
    css::uno::Sequence< OUString >                      aCopiesTo;
    css::uno::Sequence< OUString >                      aBlindCopiesTo;
    css::uno::Reference< css::mail::XSmtpService >      xSmtpServer;
    bool                                                bSendAsHTML;
    bool                                                bSendAsAttachment;
    OUString                                            sDBcolumn;
 
    OUString                                            sDBPasswordColumn;
 
    css::uno::Sequence<  css::beans::PropertyValue >    aPrintOptions;
    SwMailMergeConfigItem*                              pMailMergeConfigItem;
 
    SwMergeDescriptor( const DBManagerOptions nType,
                       SwWrtShell& rShell,
                       const svx::ODataAccessDescriptor& rDesc ) :
        nMergeType(nType),
        rSh(rShell),
        rDescriptor(rDesc),
        bCreateSingleFile( false ),
        bPrefixIsFilename( false ),
        bSendAsHTML( true ),
        bSendAsAttachment( false ),
        pMailMergeConfigItem( nullptr )
    {
        if( nType == DBMGR_MERGE_SHELL || nType == DBMGR_MERGE_PRINTER )
            bCreateSingleFile = true;
    }
};
 
class SwDoc;
 
class SW_DLLPUBLIC SwDBManager
{
    struct SwDBManager_Impl;
    class SAL_DLLPRIVATE ConnectionDisposedListener_Impl;
    class MailDispatcherListener_Impl;
 
    enum class MergeStatus
    {
        Ok = 0, Cancel, Error
    };
 
    MergeStatus     m_aMergeStatus;     
    bool            m_bInitDBFields : 1;
    bool            m_bInMerge    : 1;    
    bool            m_bMergeSilent : 1;   
    SwDSParams_t    m_DataSourceParams;
    std::unique_ptr<SwDBManager_Impl>  m_pImpl;
    const SwXMailMerge* m_pMergeEvtSrc;   
    OUString     m_sEmbeddedName;
 
    static std::vector<std::pair<SwDocShell*, OUString>> s_aUncommittedRegistrations;
 
    std::vector<OUString> m_aNotUsedConnections;
 
    void SetAsUsed(const OUString& rName);
 
    SwDoc* m_pDoc;
 
    SAL_DLLPRIVATE SwDSParam*          FindDSData(const SwDBData& rData, bool bCreate);
    SAL_DLLPRIVATE SwDSParam*          FindDSConnection(const OUString& rSource, bool bCreate);
 
    SAL_DLLPRIVATE void ImportFromConnection( SwWrtShell* pSh);
 
    SAL_DLLPRIVATE void ImportDBEntry(SwWrtShell* pSh);
 
    SAL_DLLPRIVATE bool MergeMailFiles( SwWrtShell* pSh,
                                        const SwMergeDescriptor& rMergeDescriptor );
 
    SAL_DLLPRIVATE bool ToNextMergeRecord();
    SAL_DLLPRIVATE bool IsValidMergeRecord() const;
    SAL_DLLPRIVATE void ImplDestroy();
 
    SwDBManager(SwDBManager const&) = delete;
    SwDBManager& operator=(SwDBManager const&) = delete;
 
public:
    SwDBManager(SwDoc* pDoc);
    ~SwDBManager();
 
    const SwXMailMerge *    GetMailMergeEvtSrc() const  { return m_pMergeEvtSrc; }
    void SetMailMergeEvtSrc( const SwXMailMerge *pSrc ) { m_pMergeEvtSrc = pSrc; }
 
    bool     IsMergeSilent() const           { return m_bMergeSilent; }
    void     SetMergeSilent( bool bVal )     { m_bMergeSilent = bVal; }
 
    bool            Merge( const SwMergeDescriptor& rMergeDesc );
    void            MergeCancel();
 
    bool     IsMergeOk() const     { return MergeStatus::Ok     == m_aMergeStatus; }
    bool     IsMergeError() const  { return MergeStatus::Error  <= m_aMergeStatus; }
 
    static std::shared_ptr<SwMailMergeConfigItem> PerformMailMerge(SwView const * pView);
 
    bool     IsInitDBFields() const  { return m_bInitDBFields; }
    void     SetInitDBFields(bool b) { m_bInitDBFields = b;    }
 
    bool            GetTableNames(weld::ComboBox& rBox, const OUString& rDBName);
 
    void            GetColumnNames(weld::ComboBox& rBox,
                            const OUString& rDBName, const OUString& rTableName);
    static void GetColumnNames(weld::ComboBox& rBox,
                            css::uno::Reference< css::sdbc::XConnection> const & xConnection,
                            const OUString& rTableName);
 
    static sal_uLong GetColumnFormat( css::uno::Reference< css::sdbc::XDataSource> const & xSource,
                            css::uno::Reference< css::sdbc::XConnection> const & xConnection,
                            css::uno::Reference< css::beans::XPropertySet> const & xColumn,
                            SvNumberFormatter* pNFormatr,
                            LanguageType nLanguage );
 
    sal_uLong GetColumnFormat( const OUString& rDBName,
                            const OUString& rTableName,
                            const OUString& rColNm,
                            SvNumberFormatter* pNFormatr,
                            LanguageType nLanguage );
    sal_Int32 GetColumnType( const OUString& rDBName,
                          const OUString& rTableName,
                          const OUString& rColNm );
 
    bool     IsInMerge() const   { return m_bInMerge; }
 
    void            ExecuteFormLetter(SwWrtShell& rSh,
                        const css::uno::Sequence< css::beans::PropertyValue>& rProperties);
 
    static void     InsertText(SwWrtShell& rSh,
                        const css::uno::Sequence< css::beans::PropertyValue>& rProperties);
 
    bool            IsDataSourceOpen(const OUString& rDataSource,
                                    const OUString& rTableOrQuery, bool bMergeShell);
 
    bool            OpenDataSource(const OUString& rDataSource, const OUString& rTableOrQuery);
    sal_uInt32      GetSelectedRecordId(const OUString& rDataSource, const OUString& rTableOrQuery, sal_Int32 nCommandType = -1);
    bool            GetColumnCnt(const OUString& rSourceName, const OUString& rTableName,
                            const OUString& rColumnName, sal_uInt32 nAbsRecordId, LanguageType nLanguage,
                            OUString& rResult, double* pNumber);
    css::uno::Reference< css::sdbc::XConnection> const &
                    RegisterConnection(OUString const& rSource);
 
    void            CreateDSData(const SwDBData& rData)
                        { FindDSData(rData, true); }
    const SwDSParams_t& GetDSParamArray() const { return m_DataSourceParams; }
 
    void            CloseAll(bool bIncludingMerge = true);
 
    bool            GetMergeColumnCnt(const OUString& rColumnName, LanguageType nLanguage,
                                      OUString &rResult, double *pNumber);
    bool            FillCalcWithMergeData(SvNumberFormatter *pDocFormatter,
                                          LanguageType nLanguage, SwCalc &aCalc);
    void            ToNextRecord(const OUString& rDataSource, const OUString& rTableOrQuery);
 
    sal_uInt32      GetSelectedRecordId();
    bool            ToRecordId(sal_Int32 nSet);
 
    static const SwDBData& GetAddressDBName();
 
    static OUString GetDBField(
                    css::uno::Reference< css::beans::XPropertySet > const & xColumnProp,
                    const SwDBFormatData& rDBFormatData,
                    double *pNumber = nullptr);
 
    static css::uno::Reference< css::sdbc::XConnection>
            GetConnection(const OUString& rDataSource,
                css::uno::Reference< css::sdbc::XDataSource>& rxSource,
                const SwView* pView);
 
    static css::uno::Reference< css::sdbcx::XColumnsSupplier>
            GetColumnSupplier(css::uno::Reference< css::sdbc::XConnection> const & xConnection,
                                    const OUString& rTableOrQuery,
                                    SwDBSelect eTableOrQuery = SwDBSelect::UNKNOWN);
 
    static css::uno::Sequence<OUString> GetExistingDatabaseNames();
 
    static OUString            LoadAndRegisterDataSource(weld::Window* pParent, SwDocShell* pDocShell = nullptr);
 
    static OUString            LoadAndRegisterDataSource(std::u16string_view rURI, const OUString *pDestDir);
 
    void LoadAndRegisterEmbeddedDataSource(const SwDBData& rData, const SwDocShell& rDocShell);
 
    static void RevokeDataSource(const OUString& rName);
 
    static css::uno::Reference< css::sdbc::XDataSource>
            getDataSourceAsParent(const css::uno::Reference< css::sdbc::XConnection>& _xConnection,const OUString& _sDataSourceName);
 
    static css::uno::Reference< css::sdbc::XResultSet>
            createCursor(const OUString& _sDataSourceName,
                         const OUString& _sCommand,
                         sal_Int32 _nCommandType,
                         const css::uno::Reference< css::sdbc::XConnection>& _xConnection,
                         const SwView* pView);
 
    void setEmbeddedName(const OUString& rEmbeddedName, SwDocShell& rDocShell);
    const OUString& getEmbeddedName() const;
 
    // rOwnURL should be taken using INetURLObject::GetMainURL(INetURLObject::DecodeMechanism::NONE)
    static void StoreEmbeddedDataSource(const css::uno::Reference<css::frame::XStorable>& xStorable,
                                        const css::uno::Reference<css::embed::XStorage>& xStorage,
                                        const OUString& rStreamRelPath,
                                        const OUString& rOwnURL, bool bCopyTo = false);
 
    SwDoc* getDoc() const;
    void releaseRevokeListener();
 
    void RevokeLastRegistrations();
 
    void CommitLastRegistrations();
 
    void RevokeNotUsedConnections();
};
 
namespace sw
{
enum class DBConnURIType
{
    UNKNOWN = 0,
    ODB,
    CALC,
    DBASE,
    FLAT,
    MSJET,
    MSACE,
    WRITER
};
 
DBConnURIType SW_DLLPUBLIC GetDBunoType(const INetURLObject &rURL);
}
 
#endif
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */