geotools/io/DbServerSettings.java

package skrueger.geotools.io;

import java.awt.Component;
import java.net.MalformedURLException;
import java.util.HashMap;
import java.util.regex.Pattern;

import org.apache.commons.lang.ArrayUtils;
import org.geotools.data.postgis.PostgisNGDataStoreFactory;
import org.geotools.jdbc.JDBCDataStore;
import org.geotools.jdbc.JDBCDataStoreFactory;

import schmitzm.swing.BooleanInputOption;
import schmitzm.swing.ManualInputOption;
import schmitzm.swing.ManualInputOption.Integer;
import schmitzm.swing.ManualInputOption.PasswordViewable;
import schmitzm.swing.ManualInputOption.Text;
import schmitzm.swing.MultipleOptionPane;
import schmitzm.swing.SelectionInputOption;
import schmitzm.swing.SelectionInputOption.Combo;

/**
 * This class describes all settings needed to connect to a WFS server. This
 * class extends a {@link HashMap} and contains two groups of keys:<br/>
 * The first group of keys, are all keys provided by Geotools to create a WFS
 * datastore, like: {@link JDBCDataStore#SCHEMA} .<br/>
 * The second group are additional keys defined in the enum
 * {@link DbServerSettings.Key}.<br/>
 * This class can serialize all important parameters needed to define the
 * connection into a {@link String} with {@link #toPropertiesString()} and
 * re-import the String with {@link #parsePropertiesString(String)}.
 */
public class DbServerSettings extends HashMap<Object, Object> {

        /**
         * params.put(JDBCDataStoreFactory.DBTYPE.key, "postgis");
         * params.put(JDBCDataStoreFactory.HOST.key, host); // the name or ip
         * params.put(JDBCDataStoreFactory.PORT.key, port); // the port that
         * 
         * params.put(JDBCDataStoreFactory.DATABASE.key, database); // the
         * 
         * // name params.put(JDBCDataStoreFactory.USER.key, username); // the user
         * to params.put(JDBCDataStoreFactory.PASSWD.key, password); // the
         * 
         * params.put(JDBCDataStoreFactory.SCHEMA, schema);
         * 
         * params.put(JDBCDataStoreFactory.EXPOSE_PK.key, true); *
         */

        public enum Key {
        }

        public enum DbType {
                postgis("postgresql");

                private final String protocolString;

                DbType(String protocolString) {
                        this.protocolString = protocolString;
                }

                public String getProtocolString() {
                        return protocolString;
                };
        }

        public void setPort(java.lang.Integer port) {
                put(JDBCDataStoreFactory.PORT.key, port);
        }

        public java.lang.Integer getPort() {
                java.lang.Integer port = (java.lang.Integer) get(JDBCDataStoreFactory.PORT.key);
                if (port == null)
                        return (java.lang.Integer) JDBCDataStoreFactory.PORT.sample;
                return port;
        }

        public void setSchema(String schema) {
                put(JDBCDataStoreFactory.SCHEMA.key, schema);
        }

        public String getSchema() {
                return (String) get(JDBCDataStoreFactory.SCHEMA.key);
        }

        public void setExposePrimaryKey(Boolean exportPk) {
                put(JDBCDataStoreFactory.EXPOSE_PK.key, exportPk);
        }

        public Boolean getExposePrimaryKey() {
                Boolean expk = (Boolean) get(JDBCDataStoreFactory.EXPOSE_PK.key);
                if (expk == null)
                        return (Boolean) JDBCDataStoreFactory.EXPOSE_PK.sample;
                return expk;
        }

        public void setHost(String host) {
                put(JDBCDataStoreFactory.HOST.key, host);
        }

        public String getHost() {
                return (String) get(JDBCDataStoreFactory.HOST.key);
        }

        public void setPassword(String password) {
                put(JDBCDataStoreFactory.PASSWD.key, password);
        }

        public String getPassword() {
                return (String) get(JDBCDataStoreFactory.PASSWD.key);
        }

        public void setUsername(String username) {
                put(JDBCDataStoreFactory.USER.key, username);
        }

        public String getUsername() {
                return (String) get(JDBCDataStoreFactory.USER.key);
        }

        public void setDatabase(String db) {
                put(JDBCDataStoreFactory.DATABASE.key, db);
        }

        public String getDatabase() {
                return (String) get(JDBCDataStoreFactory.DATABASE.key);
        }

        /**
         * Character used to separate the parameters when serializing settings to a
         * String
         */
        private static final String DELIMITER = "|";

        public DbServerSettings(DbType dbType) {
                setDbType(dbType);
                setHost("localhost");
                setSchema("public");
        }

        public void setDbType(DbType dbType) {
                put(PostgisNGDataStoreFactory.DBTYPE.key, dbType.toString());

                if (dbType == DbType.postgis) {
                        if (getPort() == null) {
                                // For a PostGIS DBMS automatically set the port to 5432
                                setPort(5432);
                        }
                        if (getUsername() == null) {
                                // For a PostGIS DBMS automatically set the user to postgres
                                setUsername("postgres");
                        }

                }

        }

        public DbType getDbType() {
                String dbt = (String) get(PostgisNGDataStoreFactory.DBTYPE.key);
                if (dbt != null)
                        return DbType.valueOf(dbt);
                return null;
        }

        public DbServerSettings() {
        }

        /**
         * @return <code>true</code>, if all parameters look OK, without actually
         *         opening any connection.
         */
        public boolean isWellDefined() {
                if (getDbType() == null)
                        return false;

                if (getHost() == null)
                        return false;

                if (getUsername() == null)
                        return false;

                if (getPassword() == null)
                        return false;

                if (getPort() == null)
                        return false;

                if (getSchema() == null)
                        return false;

                return true;
        }

        /**
         * @return transforms the settings to a String that can be stored in a
         *         .properties line. @see #parsePropertiesString
         */
        public String toPropertiesString() {

                StringBuffer serialized = new StringBuffer(100);

                serialized.append(getDbType().toString());
                serialized.append(DELIMITER);

                serialized.append(getHost());
                serialized.append(DELIMITER);

                serialized.append(getPort().toString());
                serialized.append(DELIMITER);

                serialized.append(getUsername());
                serialized.append(DELIMITER);

                serialized.append(getPassword());
                serialized.append(DELIMITER);

                serialized.append(getDatabase());
                serialized.append(DELIMITER);

                serialized.append(getExposePrimaryKey().toString());
                serialized.append(DELIMITER);

                serialized.append(getSchema().toString());
                serialized.append(DELIMITER);

                return serialized.toString();
        }

        /**
         * @return transforms the settings to a String that can be stored in a
         *         .properties line. @see #parsePropertiesString
         * @throws MalformedURLException
         */
        public static DbServerSettings parsePropertiesString(String propString)
                        throws MalformedURLException {

                if (propString == null || propString.isEmpty())
                        throw new IllegalArgumentException("parameter to parse was empty");

                String[] split = propString.split(Pattern.quote(DELIMITER));

                // BaseUrl
                try {
                        DbType dbt = DbType.valueOf(split[0]);

                        DbServerSettings dbServer = new DbServerSettings(dbt);

                        dbServer.setHost(split[1]);
                        dbServer.setPort(java.lang.Integer.valueOf(split[2]));
                        dbServer.setUsername(split[3]);
                        dbServer.setPassword(split[4]);
                        dbServer.setDatabase(split[5]);
                        dbServer.setExposePrimaryKey(Boolean.valueOf(split[6]));
                        dbServer.setSchema(split[7]);

                        return dbServer;
                } catch (Exception e) {
                        throw new IllegalArgumentException(e);
                }

        }

        @Override
        public String toString() {

                StringBuffer s = new StringBuffer();

                if (getDbType() != null) {
                        s.append(getDbType().getProtocolString() + "://");
                }

                s.append(getHost());

                if (getPort() != 5432) {
                        s.append(":" + getPort());
                }

                s.append("/" + getDatabase());

                return s.toString();
        }

        public void setCachedTypeNames(String[] cachedTypeNames) {
                this.cachedTypeNames = cachedTypeNames;
        }

        public String[] getCachedTypeNames() {
                return cachedTypeNames;
        }

        private String[] cachedTypeNames = null;

        public String getTitle() {
                // TODO
                return "" + getDbType();
        }

        /**
         * Opens a GUI that asks the use define a DB connection.
         * 
         * @param dbServer
         *            <code>null</code> to create a new instance, or an instance to
         *            edit.
         * @return <code>null</code> if the user cancelled the creation of a new
         *         {@link DbServerSettings}, otherwise the edited instance.
         */
        public static DbServerSettings createOrEdit(Component owner,
                        DbServerSettings dbServer) {
                boolean newCreated = false;

                if (dbServer == null) {
                        newCreated = true;
                        dbServer = new DbServerSettings(DbType.postgis);
                }

                Combo<DbType> dpTypeInput = new SelectionInputOption.Combo<DbType>(
                                "Database type", true, DbType.values(), ArrayUtils.indexOf(
                                                DbType.values(), dbServer.getDbType()), DbType.values());

                Text hostInput = new ManualInputOption.Text("Hostname", true,
                                dbServer.getHost());

                Integer portInput = new ManualInputOption.Integer("Port", true,
                                dbServer.getPort());

                Text databaseInput = new ManualInputOption.Text("Database", true,
                                dbServer.getDatabase());

                Text schemaInput = new ManualInputOption.Text("Schema", true,
                                dbServer.getSchema());

                Text userInput = new ManualInputOption.Text("Username", true,
                                dbServer.getUsername());

                PasswordViewable passwdInput = new ManualInputOption.PasswordViewable(
                                "Passwort", true, dbServer.getPassword());

                BooleanInputOption exposePkInput = new BooleanInputOption(
                                "Expose primary keys", dbServer.getExposePrimaryKey());

                Object[] input = MultipleOptionPane.showMultipleInputDialog(owner,
                                "DB Connection paramters", dpTypeInput, hostInput, portInput,
                                databaseInput, schemaInput, userInput, passwdInput,
                                exposePkInput);

                if (input == null) {
                        if (newCreated)
                                return null;
                        else
                                return dbServer;
                } else {
                        dbServer.setDbType((DbType) input[0]);
                        dbServer.setHost((String) input[1]);
                        dbServer.setPort((java.lang.Integer) input[2]);
                        dbServer.setDatabase((String) input[3]);
                        dbServer.setSchema((String) input[4]);
                        dbServer.setUsername((String) input[5]);
                        dbServer.setPassword(String.valueOf((char[]) input[6]));
                        dbServer.setExposePrimaryKey((Boolean) input[7]);
                }

                return dbServer;
        }
}
1	alfonx	1161	package skrueger.geotools.io;
2
3			import java.awt.Component;
4			import java.net.MalformedURLException;
5			import java.util.HashMap;
6			import java.util.regex.Pattern;
7
8			import org.apache.commons.lang.ArrayUtils;
9			import org.geotools.data.postgis.PostgisNGDataStoreFactory;
10			import org.geotools.jdbc.JDBCDataStore;
11			import org.geotools.jdbc.JDBCDataStoreFactory;
12
13			import schmitzm.swing.BooleanInputOption;
14			import schmitzm.swing.ManualInputOption;
15			import schmitzm.swing.ManualInputOption.Integer;
16			import schmitzm.swing.ManualInputOption.PasswordViewable;
17			import schmitzm.swing.ManualInputOption.Text;
18			import schmitzm.swing.MultipleOptionPane;
19			import schmitzm.swing.SelectionInputOption;
20			import schmitzm.swing.SelectionInputOption.Combo;
21
22			/**
23			* This class describes all settings needed to connect to a WFS server. This
24			* class extends a {@link HashMap} and contains two groups of keys:<br/>
25			* The first group of keys, are all keys provided by Geotools to create a WFS
26			* datastore, like: {@link JDBCDataStore#SCHEMA} .<br/>
27			* The second group are additional keys defined in the enum
28			* {@link DbServerSettings.Key}.<br/>
29			* This class can serialize all important parameters needed to define the
30			* connection into a {@link String} with {@link #toPropertiesString()} and
31			* re-import the String with {@link #parsePropertiesString(String)}.
32			*/
33			public class DbServerSettings extends HashMap<Object, Object> {
34
35			/**
36			* params.put(JDBCDataStoreFactory.DBTYPE.key, "postgis");
37			* params.put(JDBCDataStoreFactory.HOST.key, host); // the name or ip
38			* params.put(JDBCDataStoreFactory.PORT.key, port); // the port that
39			*
40			* params.put(JDBCDataStoreFactory.DATABASE.key, database); // the
41			*
42			* // name params.put(JDBCDataStoreFactory.USER.key, username); // the user
43			* to params.put(JDBCDataStoreFactory.PASSWD.key, password); // the
44			*
45			* params.put(JDBCDataStoreFactory.SCHEMA, schema);
46			*
47			* params.put(JDBCDataStoreFactory.EXPOSE_PK.key, true); *
48			*/
49
50			public enum Key {
51			}
52
53			public enum DbType {
54			postgis("postgresql");
55
56			private final String protocolString;
57
58			DbType(String protocolString) {
59			this.protocolString = protocolString;
60			}
61
62			public String getProtocolString() {
63			return protocolString;
64			};
65			}
66
67			public void setPort(java.lang.Integer port) {
68			put(JDBCDataStoreFactory.PORT.key, port);
69			}
70
71			public java.lang.Integer getPort() {
72			java.lang.Integer port = (java.lang.Integer) get(JDBCDataStoreFactory.PORT.key);
73			if (port == null)
74			return (java.lang.Integer) JDBCDataStoreFactory.PORT.sample;
75			return port;
76			}
77
78			public void setSchema(String schema) {
79			put(JDBCDataStoreFactory.SCHEMA.key, schema);
80			}
81
82			public String getSchema() {
83			return (String) get(JDBCDataStoreFactory.SCHEMA.key);
84			}
85
86			public void setExposePrimaryKey(Boolean exportPk) {
87			put(JDBCDataStoreFactory.EXPOSE_PK.key, exportPk);
88			}
89
90			public Boolean getExposePrimaryKey() {
91			Boolean expk = (Boolean) get(JDBCDataStoreFactory.EXPOSE_PK.key);
92			if (expk == null)
93			return (Boolean) JDBCDataStoreFactory.EXPOSE_PK.sample;
94			return expk;
95			}
96
97			public void setHost(String host) {
98			put(JDBCDataStoreFactory.HOST.key, host);
99			}
100
101			public String getHost() {
102			return (String) get(JDBCDataStoreFactory.HOST.key);
103			}
104
105			public void setPassword(String password) {
106			put(JDBCDataStoreFactory.PASSWD.key, password);
107			}
108
109			public String getPassword() {
110			return (String) get(JDBCDataStoreFactory.PASSWD.key);
111			}
112
113			public void setUsername(String username) {
114			put(JDBCDataStoreFactory.USER.key, username);
115			}
116
117			public String getUsername() {
118			return (String) get(JDBCDataStoreFactory.USER.key);
119			}
120
121			public void setDatabase(String db) {
122			put(JDBCDataStoreFactory.DATABASE.key, db);
123			}
124
125			public String getDatabase() {
126			return (String) get(JDBCDataStoreFactory.DATABASE.key);
127			}
128
129			/**
130			* Character used to separate the parameters when serializing settings to a
131			* String
132			*/
133			private static final String DELIMITER = "\|";
134
135			public DbServerSettings(DbType dbType) {
136			setDbType(dbType);
137			setHost("localhost");
138			setSchema("public");
139			}
140
141			public void setDbType(DbType dbType) {
142			put(PostgisNGDataStoreFactory.DBTYPE.key, dbType.toString());
143
144			if (dbType == DbType.postgis) {
145			if (getPort() == null) {
146			// For a PostGIS DBMS automatically set the port to 5432
147			setPort(5432);
148			}
149			if (getUsername() == null) {
150			// For a PostGIS DBMS automatically set the user to postgres
151			setUsername("postgres");
152			}
153
154			}
155
156			}
157
158			public DbType getDbType() {
159			String dbt = (String) get(PostgisNGDataStoreFactory.DBTYPE.key);
160			if (dbt != null)
161			return DbType.valueOf(dbt);
162			return null;
163			}
164
165			public DbServerSettings() {
166			}
167
168			/**
169			* @return <code>true</code>, if all parameters look OK, without actually
170			* opening any connection.
171			*/
172			public boolean isWellDefined() {
173			if (getDbType() == null)
174			return false;
175
176			if (getHost() == null)
177			return false;
178
179			if (getUsername() == null)
180			return false;
181
182			if (getPassword() == null)
183			return false;
184
185			if (getPort() == null)
186			return false;
187
188			if (getSchema() == null)
189			return false;
190
191			return true;
192			}
193
194			/**
195			* @return transforms the settings to a String that can be stored in a
196			* .properties line. @see #parsePropertiesString
197			*/
198			public String toPropertiesString() {
199
200			StringBuffer serialized = new StringBuffer(100);
201
202			serialized.append(getDbType().toString());
203			serialized.append(DELIMITER);
204
205	alfonx	1162	serialized.append(getHost());
206	alfonx	1161	serialized.append(DELIMITER);
207
208			serialized.append(getPort().toString());
209			serialized.append(DELIMITER);
210
211	alfonx	1162	serialized.append(getUsername());
212	alfonx	1161	serialized.append(DELIMITER);
213
214	alfonx	1162	serialized.append(getPassword());
215	alfonx	1161	serialized.append(DELIMITER);
216
217	alfonx	1162	serialized.append(getDatabase());
218	alfonx	1161	serialized.append(DELIMITER);
219
220			serialized.append(getExposePrimaryKey().toString());
221			serialized.append(DELIMITER);
222
223			serialized.append(getSchema().toString());
224			serialized.append(DELIMITER);
225
226			return serialized.toString();
227			}
228
229			/**
230			* @return transforms the settings to a String that can be stored in a
231			* .properties line. @see #parsePropertiesString
232			* @throws MalformedURLException
233			*/
234			public static DbServerSettings parsePropertiesString(String propString)
235			throws MalformedURLException {
236
237			if (propString == null \|\| propString.isEmpty())
238			throw new IllegalArgumentException("parameter to parse was empty");
239
240			String[] split = propString.split(Pattern.quote(DELIMITER));
241
242			// BaseUrl
243			try {
244			DbType dbt = DbType.valueOf(split[0]);
245
246			DbServerSettings dbServer = new DbServerSettings(dbt);
247
248			dbServer.setHost(split[1]);
249			dbServer.setPort(java.lang.Integer.valueOf(split[2]));
250			dbServer.setUsername(split[3]);
251			dbServer.setPassword(split[4]);
252			dbServer.setDatabase(split[5]);
253			dbServer.setExposePrimaryKey(Boolean.valueOf(split[6]));
254			dbServer.setSchema(split[7]);
255
256			return dbServer;
257			} catch (Exception e) {
258			throw new IllegalArgumentException(e);
259			}
260
261			}
262
263			@Override
264			public String toString() {
265
266			StringBuffer s = new StringBuffer();
267
268			if (getDbType() != null) {
269			s.append(getDbType().getProtocolString() + "://");
270			}
271
272			s.append(getHost());
273
274			if (getPort() != 5432) {
275			s.append(":" + getPort());
276			}
277
278			s.append("/" + getDatabase());
279
280			return s.toString();
281			}
282
283			public void setCachedTypeNames(String[] cachedTypeNames) {
284			this.cachedTypeNames = cachedTypeNames;
285			}
286
287			public String[] getCachedTypeNames() {
288			return cachedTypeNames;
289			}
290
291			private String[] cachedTypeNames = null;
292
293			public String getTitle() {
294			// TODO
295			return "" + getDbType();
296			}
297
298			/**
299			* Opens a GUI that asks the use define a DB connection.
300			*
301			* @param dbServer
302			* <code>null</code> to create a new instance, or an instance to
303			* edit.
304			* @return <code>null</code> if the user cancelled the creation of a new
305			* {@link DbServerSettings}, otherwise the edited instance.
306			*/
307			public static DbServerSettings createOrEdit(Component owner,
308			DbServerSettings dbServer) {
309			boolean newCreated = false;
310
311			if (dbServer == null) {
312			newCreated = true;
313			dbServer = new DbServerSettings(DbType.postgis);
314			}
315
316			Combo<DbType> dpTypeInput = new SelectionInputOption.Combo<DbType>(
317			"Database type", true, DbType.values(), ArrayUtils.indexOf(
318			DbType.values(), dbServer.getDbType()), DbType.values());
319
320			Text hostInput = new ManualInputOption.Text("Hostname", true,
321			dbServer.getHost());
322
323			Integer portInput = new ManualInputOption.Integer("Port", true,
324			dbServer.getPort());
325
326			Text databaseInput = new ManualInputOption.Text("Database", true,
327			dbServer.getDatabase());
328
329			Text schemaInput = new ManualInputOption.Text("Schema", true,
330			dbServer.getSchema());
331
332			Text userInput = new ManualInputOption.Text("Username", true,
333			dbServer.getUsername());
334
335			PasswordViewable passwdInput = new ManualInputOption.PasswordViewable(
336			"Passwort", true, dbServer.getPassword());
337
338			BooleanInputOption exposePkInput = new BooleanInputOption(
339			"Expose primary keys", dbServer.getExposePrimaryKey());
340
341			Object[] input = MultipleOptionPane.showMultipleInputDialog(owner,
342			"DB Connection paramters", dpTypeInput, hostInput, portInput,
343			databaseInput, schemaInput, userInput, passwdInput,
344			exposePkInput);
345
346			if (input == null) {
347			if (newCreated)
348			return null;
349			else
350			return dbServer;
351			} else {
352			dbServer.setDbType((DbType) input[0]);
353			dbServer.setHost((String) input[1]);
354			dbServer.setPort((java.lang.Integer) input[2]);
355			dbServer.setDatabase((String) input[3]);
356			dbServer.setSchema((String) input[4]);
357			dbServer.setUsername((String) input[5]);
358			dbServer.setPassword(String.valueOf((char[]) input[6]));
359			dbServer.setExposePrimaryKey((Boolean) input[7]);
360			}
361
362			return dbServer;
363			}
364			}
Name	Value
svn:eol-style	native
svn:keywords	Id URL
svn:mime-type	text/plain