geotools/io/GtDbServerSettings.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().toString());
                serialized.append(DELIMITER);

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

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

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

                serialized.append(getDatabase().toString());
                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	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	serialized.append(getHost().toString());
206	serialized.append(DELIMITER);
207
208	serialized.append(getPort().toString());
209	serialized.append(DELIMITER);
210
211	serialized.append(getUsername().toString());
212	serialized.append(DELIMITER);
213
214	serialized.append(getPassword().toString());
215	serialized.append(DELIMITER);
216
217	serialized.append(getDatabase().toString());
218	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