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.apache.commons.lang.StringUtils;
import org.geotools.data.postgis.PostgisNGDataStoreFactory;
import org.geotools.jdbc.JDBCDataStore;
import org.geotools.jdbc.JDBCDataStoreFactory;
import org.jfree.util.Log;

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 ServerSettings<Object, Object> {

        public enum DbType {
                postgis("postgresql");

                private final String protocolString;

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

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

        /**
         * 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 {
        }

        /**
         * 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(
                                "Password", 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;

        }

        /**
         * @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");
                try {

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

                        int i = 0;
                        DbServerSettings dbServer = new DbServerSettings(
                                        DbType.valueOf(split[i++]));

                        dbServer.setTitle(split[i++]);
                        dbServer.setHost(split[i++]);
                        dbServer.setPort(java.lang.Integer.valueOf(split[i++]));
                        dbServer.setUsername(StringUtils.stripToNull(split[i++]));
                        dbServer.setPassword(split[i++]);
                        dbServer.setDatabase(split[i++]);
                        dbServer.setExposePrimaryKey(Boolean.valueOf(split[i++]));
                        dbServer.setSchema(stringOrNull(split[i++]));

                        return dbServer;
                } catch (Exception e) {
                        Log.warn("couldn't parse " + propString, e);
                        return null;
                }
        }

        private String[] cachedTypeNames = null;

        public DbServerSettings() {
                this(DbType.postgis);
        }

        public DbServerSettings(DbType dbType) {
                setDbType(dbType);
                setHost("localhost");
                setSchema("public");
                put(JDBCDataStoreFactory.PK_METADATA_TABLE.key, null);
        }

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

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

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

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

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

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

        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 String getSchema() {
                return (String) get(JDBCDataStoreFactory.SCHEMA.key);
        }

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

        /**
         * @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;
        }

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

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

        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 void setExposePrimaryKey(Boolean exportPk) {
                put(JDBCDataStoreFactory.EXPOSE_PK.key, exportPk);
        }

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

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

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

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

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

        /**
         * @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(getTitle());
                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();
        }

        @Override
        public String toString() {

                StringBuffer s = new StringBuffer();

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

                s.append(getHost());

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

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

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