001/*
002 * This library is part of OpenCms -
003 * the Open Source Content Management System
004 *
005 * Copyright (c) Alkacon Software GmbH & Co. KG (http://www.alkacon.com)
006 *
007 * This library is free software; you can redistribute it and/or
008 * modify it under the terms of the GNU Lesser General Public
009 * License as published by the Free Software Foundation; either
010 * version 2.1 of the License, or (at your option) any later version.
011 *
012 * This library is distributed in the hope that it will be useful,
013 * but WITHOUT ANY WARRANTY; without even the implied warranty of
014 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
015 * Lesser General Public License for more details.
016 *
017 * For further information about Alkacon Software, please see the
018 * company website: http://www.alkacon.com
019 *
020 * For further information about OpenCms, please see the
021 * project website: http://www.opencms.org
022 *
023 * You should have received a copy of the GNU Lesser General Public
024 * License along with this library; if not, write to the Free Software
025 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
026 */
027
028package org.opencms.setup.ui;
029
030import org.opencms.setup.CmsSetupBean;
031import org.opencms.ui.CmsVaadinUtils;
032
033import java.io.File;
034import java.util.HashMap;
035import java.util.Map;
036
037import com.vaadin.ui.CheckBox;
038import com.vaadin.ui.Component;
039import com.vaadin.ui.Panel;
040import com.vaadin.ui.PasswordField;
041import com.vaadin.ui.TextField;
042import com.vaadin.ui.VerticalLayout;
043
044/**
045 * Form for database settings.
046 */
047public class CmsDbSettingsPanel extends VerticalLayout {
048
049    /** Form field. */
050    private CheckBox m_createDb;
051
052    /** Form field. */
053    private CheckBox m_createTables;
054
055    /** Form field. */
056    private TextField m_dbCreateConStr;
057
058    /** Form field. */
059    private PasswordField m_dbCreatePwd;
060
061    /** Form field. */
062    private TextField m_dbCreateUser;
063
064    /** Form field. */
065    private TextField m_dbName;
066
067    /** Form field. */
068    private PasswordField m_dbWorkPwd;
069
070    /** Form field. */
071    private TextField m_dbWorkUser;
072
073    /** Form field. */
074    private TextField m_defaultTablespace;
075
076    /** Form field. */
077    private CheckBox m_dropDatabase;
078
079    /** Form field. */
080    private TextField m_indexTablespace;
081
082    /** Setup bean. */
083    private CmsSetupBean m_setupBean;
084
085    /** Form field. */
086    private Panel m_setupPanel;
087
088    private TextField m_templateDb;
089
090    /** Form field. */
091    private TextField m_temporaryTablespace;
092
093    public CmsDbSettingsPanel(CmsSetupBean setupBean) {
094
095        super();
096        m_setupBean = setupBean;
097        CmsVaadinUtils.readAndLocalizeDesign(this, null, null);
098
099    }
100
101    /**
102     * Gets the value of the 'create database' check box.
103     *
104     * @return the value of the check box
105     */
106    public boolean getCreateDb() {
107
108        return m_createDb.getValue().booleanValue();
109    }
110
111    /**
112     * Gets the value of the 'create tables' check box.
113     *
114     * @return the value of the check box
115     */
116    public boolean getCreateTables() {
117
118        return m_createTables.isVisible() ? m_createTables.getValue() : m_createDb.getValue();
119    }
120
121    /**
122     * Gets the value of the 'drop database' check box.
123     *
124     * @return the value of the check box
125     */
126    public boolean getDropDb() {
127
128        return m_dropDatabase.getValue().booleanValue();
129    }
130
131    /**
132     * Initializes fields with data from setup bean.
133     *
134     * @param the webapp name (null for root webapp)
135     */
136    public void initFromSetupBean(String webapp) {
137
138        String db = m_setupBean.getDatabase();
139        CmsSetupBean bean = m_setupBean;
140        Map<String, String[]> params = new HashMap<>();
141        m_setupPanel.setVisible(true);
142        switch (db) {
143            case "mysql":
144            case "mssql":
145                setVisible(
146                    m_dbCreateUser,
147                    m_dbCreatePwd,
148                    m_dbWorkUser,
149                    m_dbWorkPwd,
150                    m_dbCreateConStr,
151                    m_dbName,
152                    m_createDb,
153                    m_dropDatabase);
154                m_dbCreateUser.setValue(bean.getDbCreateUser());
155                m_dbCreatePwd.setValue(bean.getDbCreatePwd());
156                m_dbWorkUser.setValue(bean.getDbWorkUser());
157                m_dbWorkPwd.setValue(bean.getDbWorkPwd());
158                m_dbCreateConStr.setValue(bean.getDbCreateConStr());
159                m_dbName.setValue(webapp != null ? webapp : bean.getDb());
160                m_createDb.setValue(true);
161                m_createDb.setCaption("Create database and tables");
162                m_dropDatabase.setValue(false);
163                break;
164            case "postgresql":
165                setVisible(
166                    m_dbCreateUser,
167                    m_dbCreatePwd,
168                    m_dbWorkUser,
169                    m_dbWorkPwd,
170                    m_dbCreateConStr,
171                    m_dbName,
172                    m_createDb,
173                    m_createTables,
174                    m_dropDatabase,
175                    m_templateDb);
176                m_dbCreateUser.setValue(bean.getDbCreateUser());
177                m_dbCreatePwd.setValue(bean.getDbCreatePwd());
178                m_dbWorkUser.setValue(bean.getDbWorkUser());
179                m_dbWorkPwd.setValue(bean.getDbWorkPwd());
180                m_dbCreateConStr.setValue(bean.getDbCreateConStr());
181                m_dbName.setValue(webapp != null ? webapp : bean.getDb());
182                m_createDb.setValue(true);
183                m_createDb.setCaption("Create database and user");
184                m_templateDb.setValue(dbProp("templateDb"));
185                m_createTables.setValue(true);
186                m_dropDatabase.setValue(false);
187                break;
188            case "hsqldb":
189                setVisible(
190                    m_dbCreateUser,
191                    m_dbCreatePwd,
192                    m_dbWorkUser,
193                    m_dbWorkPwd,
194                    m_dbCreateConStr,
195                    m_createDb,
196                    m_dropDatabase);
197
198                m_dbCreateUser.setValue(bean.getDbCreateUser());
199                m_dbCreatePwd.setValue(bean.getDbCreatePwd());
200                m_dbWorkUser.setValue(bean.getDbWorkUser());
201                m_dbWorkPwd.setValue(bean.getDbWorkPwd());
202                m_createDb.setValue(true);
203                m_createDb.setCaption("Create database and tables");
204                m_dropDatabase.setValue(false);
205                String origCreateConStr = bean.getDbProperty("hsqldb.constr");
206                String createConStr = bean.getDbCreateConStr();
207                if ((origCreateConStr != null) && origCreateConStr.equals(createConStr)) {
208                    createConStr = "jdbc:hsqldb:file:"
209                        + bean.getWebAppRfsPath()
210                        + "WEB-INF"
211                        + File.separatorChar
212                        + "hsqldb"
213                        + File.separatorChar
214                        + "opencms;shutdown=false";
215                }
216                m_dbCreateConStr.setValue(createConStr);
217                break;
218            case "oracle":
219                setVisible(
220                    m_dbCreateUser,
221                    m_dbCreatePwd,
222                    m_dbWorkUser,
223                    m_dbWorkPwd,
224                    m_dbCreateConStr,
225                    m_createDb,
226                    m_createTables,
227                    m_dropDatabase,
228                    m_temporaryTablespace,
229                    m_indexTablespace,
230                    m_defaultTablespace);
231                m_dbCreateUser.setValue(bean.getDbCreateUser());
232                m_dbCreatePwd.setValue(bean.getDbCreatePwd());
233                m_dbWorkUser.setValue(bean.getDbWorkUser());
234                m_dbWorkPwd.setValue(bean.getDbWorkPwd());
235                m_dbCreateConStr.setValue(bean.getDbCreateConStr());
236                m_dbName.setValue(webapp != null ? webapp : bean.getDb());
237                m_createDb.setValue(true);
238                m_createDb.setCaption("Create user");
239                m_createTables.setValue(true);
240                m_dropDatabase.setValue(false);
241                m_temporaryTablespace.setValue(dbProp("temporaryTablespace"));
242                m_indexTablespace.setValue(dbProp("indexTablespace"));
243                m_defaultTablespace.setValue(dbProp("defaultTablespace"));
244                break;
245            case "db2":
246            case "as400":
247                setVisible(m_dbWorkUser, m_dbWorkPwd, m_dbCreateConStr, m_dbName, m_createTables);
248                m_setupPanel.setVisible(false);
249                m_dbWorkUser.setValue(bean.getDbWorkUser());
250                m_dbWorkPwd.setValue(bean.getDbWorkPwd());
251                m_dbCreateConStr.setValue(bean.getDbCreateConStr());
252                m_dbName.setValue(webapp != null ? webapp : bean.getDb());
253                m_createDb.setValue(false);
254                m_createTables.setValue(true);
255                m_dropDatabase.setValue(true);
256                break;
257            default:
258                break;
259        }
260    }
261
262    /**
263     * Saves form field data to setup bean.
264     */
265    public void saveToSetupBean() {
266
267        Map<String, String[]> result = new HashMap<String, String[]>();
268
269        CmsSetupBean bean = m_setupBean;
270        if (m_dbCreateUser.isVisible()) {
271            bean.setDbCreateUser(m_dbCreateUser.getValue());
272        }
273        if (m_dbCreatePwd.isVisible()) {
274            bean.setDbCreatePwd(m_dbCreatePwd.getValue());
275        }
276        if (m_dbWorkUser.isVisible()) {
277            bean.setDbWorkUser(m_dbWorkUser.getValue());
278        }
279
280        if (m_templateDb.isVisible()) {
281            setDbProp("templateDb", m_templateDb.getValue());
282        }
283
284        if (m_dbWorkPwd.isVisible()) {
285            bean.setDbWorkPwd(m_dbWorkPwd.getValue());
286        }
287
288        if (m_dbCreateConStr.isVisible()) {
289            bean.setDbCreateConStr(m_dbCreateConStr.getValue());
290        }
291
292        if (m_dbName.isVisible()) {
293            bean.setDb(m_dbName.getValue());
294        }
295
296        result.put("dbCreateConStr", new String[] {m_dbCreateConStr.getValue()});
297
298        result.put("dbName", new String[] {bean.getDatabase()});
299        result.put("dbProduct", new String[] {bean.getDatabase()});
300        result.put("dbProvider", new String[] {"sql"});
301        result.put("dbName", new String[] {m_dbName.getValue()});
302        result.put("db", new String[] {bean.getDb()});
303        result.put("createDb", new String[] {Boolean.toString(m_createDb.getValue().booleanValue())});
304        result.put("createTables", new String[] {Boolean.toString(m_createTables.getValue().booleanValue())});
305        result.put("jdbcDriver", new String[] {dbProp("driver")});
306        result.put("templateDb", new String[] {dbProp("templateDb")});
307        result.put("dbCreateUser", new String[] {bean.getDbCreateUser()});
308        result.put("dbCreatePwd", new String[] {bean.getDbCreatePwd()});
309        result.put("dbWorkUser", new String[] {bean.getDbWorkUser()});
310        result.put("dbWorkPwd", new String[] {bean.getDbWorkPwd()});
311        result.put("dbDefaultTablespace", new String[] {m_defaultTablespace.getValue()});
312        result.put("dbTemporaryTablespace", new String[] {m_temporaryTablespace.getValue()});
313        result.put("dbIndexTablespace", new String[] {m_indexTablespace.getValue()});
314        // result.put("servletMapping", new String[] {getServeltMapping()});
315        result.put("submit", new String[] {Boolean.TRUE.toString()});
316        bean.setDbParamaters(result, bean.getDatabase(), null, null);
317
318    }
319
320    /**
321     * Accesses a property from the DB configuration for the selected DB.
322     *
323     * @param name the name of the property
324     * @return the value of the property
325     */
326    private String dbProp(String name) {
327
328        String dbType = m_setupBean.getDatabase();
329        Object prop = m_setupBean.getDatabaseProperties().get(dbType).get(dbType + "." + name);
330        if (prop == null) {
331            return "";
332        }
333        return prop.toString();
334    }
335
336    private void setDbProp(String key, String value) {
337
338        String db = m_setupBean.getDatabase();
339        m_setupBean.setDbProperty(db + "." + key, value);
340    }
341
342    /**
343     * Sets the visibility of the given components to 'true' .
344     *
345     * @param components the components to show
346     */
347    private void setVisible(Component... components) {
348
349        for (Component component : components) {
350            component.setVisible(true);
351        }
352    }
353
354}