geotools/io/WfsServerSettings.java

package skrueger.geotools.io;

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

import org.apache.commons.lang.ArrayUtils;
import org.geotools.data.DataUtilities;
import org.geotools.data.wfs.WFSDataStoreFactory;

import schmitzm.swing.ManualInputOption;
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 WFSDataStoreFactory#URL} or
 * {@link WFSDataStoreFactory#USERNAME} .<br/>
 * The second group are additional keys defined in the enum
 * {@link WfsServerSettings.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 WfsServerSettings extends HashMap<Object, Object> {

        public enum Key {
                BASE_URL, VERSION
        }

        public enum WfsProtocollVersion {
                v1_1_1("1.1.1"), v1_1_0("1.1.0"), v1_0_0("1.0.0");

                private final String versionString;

                private WfsProtocollVersion(String versionString) {
                        this.versionString = versionString;
                }

                public String getVersionString() {
                        return versionString;
                }
        }

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

        public WfsServerSettings(URL baseUrl, WfsProtocollVersion version) {
                setVersion(version);
                setBaseUrl(baseUrl);
        }

        public WfsServerSettings() {
                try {
                        setBaseUrl(new URL("http://localhost:8080/geoserver/ows"));
                } catch (MalformedURLException e) {
                        throw new RuntimeException(e);
                }
        }

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

        /**
         * @return <code>null</code> if not correctly defined, otherwise the URL of
         *         the GetCapabilites request.
         */
        public URL getCapabilitiesUrl() {
                return (URL) get(WFSDataStoreFactory.URL.key);
        }

        public URL getBaseUrl() {
                return (URL) get(Key.BASE_URL);
        }

        public void setBaseUrl(URL baseUrl) {

                if (get(Key.BASE_URL) != baseUrl) {
                        setCachedTypeNames(null);
                }

                put(Key.BASE_URL, baseUrl);

                updateCapabilitesUrl();
        }

        public boolean updateCapabilitesUrl() {
                remove(WFSDataStoreFactory.URL.key);

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

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

                try {
                        URL fullUrl = DataUtilities.extendURL(getBaseUrl(),
                                        "?service=wfs&version=" + getVersion().getVersionString()
                                                        + "&request=GetCapabilities");

                        put(WFSDataStoreFactory.URL.key, fullUrl);

                        return true;
                } catch (MalformedURLException e) {
                        return false;
                }
        }

        public WfsProtocollVersion getVersion() {
                return (WfsProtocollVersion) get(Key.VERSION);
        }

        public void setVersion(WfsProtocollVersion version) {

                if (get(Key.VERSION) != version) {
                        setCachedTypeNames(null);
                }

                put(Key.VERSION, version);
                updateCapabilitesUrl();
        }

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

                // BaseUrl
                serialized.append(getBaseUrl().toString());
                serialized.append(DELIMITER);

                // Version
                serialized.append(getVersion().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 WfsServerSettings parsePropertiesString(String propString)
                        throws MalformedURLException {

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

                // BaseUrl
                URL baseUrl = new URL(split[0]);

                // Version
                WfsProtocollVersion v = WfsProtocollVersion.valueOf(split[1]);

                return new WfsServerSettings(baseUrl, v);
        }

        @Override
        public String toString() {
                StringBuffer s = new StringBuffer();

                URL baseUrl = getBaseUrl();
                WfsProtocollVersion version = getVersion();

                if (baseUrl != null)
                        s.append(baseUrl.toString() + " ");

                if (version != null)
                        s.append(version.getVersionString());

                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 "" + getBaseUrl() + " " + getVersion();
        }

        /**
         * Opens a GUI that asks the use define a DB connection.
         * 
         * @param wfsServer
         *            <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 WfsServerSettings createOrEdit(Component owner,
                        WfsServerSettings wfsServer) {
                boolean newCreated = false;

                if (wfsServer == null) {
                        newCreated = true;
                        wfsServer = new WfsServerSettings();
                }

                Text hostInput = new ManualInputOption.Text(
                                "BaseURL (without any paramters)", true, wfsServer.getBaseUrl()
                                                .toString());

                Combo<WfsProtocollVersion> versionInput = new SelectionInputOption.Combo<WfsProtocollVersion>(
                                "WFS Version", true, WfsProtocollVersion.values(),
                                ArrayUtils.indexOf(WfsProtocollVersion.values(),
                                                wfsServer.getVersion()), WfsProtocollVersion.values());

                Object[] input = MultipleOptionPane.showMultipleInputDialog(owner,
                                "WFS Connection parameters", hostInput, versionInput);

                if (input == null) {
                        if (newCreated)
                                return null;
                        else
                                return wfsServer;
                } else {
                        wfsServer.setBaseUrl((String) input[0]);
                        wfsServer.setVersion(((WfsProtocollVersion) input[1]));
                }

                return wfsServer;

        }

        /**
         * Set the BaseUrl as a String. Any pending parameters are automatically cut
         * of.
         */
        public void setBaseUrl(String urlString) {
                try {
                        // Cutoff any parameters
                        if (urlString.indexOf("?") > -1) {
                                urlString = urlString.substring(0, urlString.indexOf("?"));
                        }

                        setBaseUrl(new URL(urlString));
                } catch (MalformedURLException e) {
                        throw new RuntimeException(e);
                }
        }
}
1	package skrueger.geotools.io;
2
3	import java.awt.Component;
4	import java.net.MalformedURLException;
5	import java.net.URL;
6	import java.util.HashMap;
7	import java.util.regex.Pattern;
8
9	import org.apache.commons.lang.ArrayUtils;
10	import org.geotools.data.DataUtilities;
11	import org.geotools.data.wfs.WFSDataStoreFactory;
12
13	import schmitzm.swing.ManualInputOption;
14	import schmitzm.swing.ManualInputOption.Text;
15	import schmitzm.swing.MultipleOptionPane;
16	import schmitzm.swing.SelectionInputOption;
17	import schmitzm.swing.SelectionInputOption.Combo;
18
19	/**
20	* This class describes all settings needed to connect to a WFS server. This
21	* class extends a {@link HashMap} and contains two groups of keys:<br/>
22	* The first group of keys, are all keys provided by Geotools to create a WFS
23	* datastore, like: {@link WFSDataStoreFactory#URL} or
24	* {@link WFSDataStoreFactory#USERNAME} .<br/>
25	* The second group are additional keys defined in the enum
26	* {@link WfsServerSettings.Key}.<br/>
27	* This class can serialize all important parameters needed to define the
28	* connection into a {@link String} with {@link #toPropertiesString()} and
29	* re-import the String with {@link #parsePropertiesString(String)}.
30	*/
31	public class WfsServerSettings extends HashMap<Object, Object> {
32
33	public enum Key {
34	BASE_URL, VERSION
35	}
36
37	public enum WfsProtocollVersion {
38	v1_1_1("1.1.1"), v1_1_0("1.1.0"), v1_0_0("1.0.0");
39
40	private final String versionString;
41
42	private WfsProtocollVersion(String versionString) {
43	this.versionString = versionString;
44	}
45
46	public String getVersionString() {
47	return versionString;
48	}
49	}
50
51	/**
52	* Character used to separate the parameters when serializing settings to a
53	* String
54	*/
55	private static final String DELIMITER = "\|";
56
57	public WfsServerSettings(URL baseUrl, WfsProtocollVersion version) {
58	setVersion(version);
59	setBaseUrl(baseUrl);
60	}
61
62	public WfsServerSettings() {
63	try {
64	setBaseUrl(new URL("http://localhost:8080/geoserver/ows"));
65	} catch (MalformedURLException e) {
66	throw new RuntimeException(e);
67	}
68	}
69
70	/**
71	* @return <code>true</code>, if all parameters look OK, without actually
72	* opening any connection.
73	*/
74	public boolean isWellDefined() {
75	return updateCapabilitesUrl();
76	}
77
78	/**
79	* @return <code>null</code> if not correctly defined, otherwise the URL of
80	* the GetCapabilites request.
81	*/
82	public URL getCapabilitiesUrl() {
83	return (URL) get(WFSDataStoreFactory.URL.key);
84	}
85
86	public URL getBaseUrl() {
87	return (URL) get(Key.BASE_URL);
88	}
89
90	public void setBaseUrl(URL baseUrl) {
91
92	if (get(Key.BASE_URL) != baseUrl) {
93	setCachedTypeNames(null);
94	}
95
96	put(Key.BASE_URL, baseUrl);
97
98	updateCapabilitesUrl();
99	}
100
101	public boolean updateCapabilitesUrl() {
102	remove(WFSDataStoreFactory.URL.key);
103
104	if (getBaseUrl() == null)
105	return false;
106
107	if (getVersion() == null)
108	return false;
109
110	try {
111	URL fullUrl = DataUtilities.extendURL(getBaseUrl(),
112	"?service=wfs&version=" + getVersion().getVersionString()
113	+ "&request=GetCapabilities");
114
115	put(WFSDataStoreFactory.URL.key, fullUrl);
116
117	return true;
118	} catch (MalformedURLException e) {
119	return false;
120	}
121	}
122
123	public WfsProtocollVersion getVersion() {
124	return (WfsProtocollVersion) get(Key.VERSION);
125	}
126
127	public void setVersion(WfsProtocollVersion version) {
128
129	if (get(Key.VERSION) != version) {
130	setCachedTypeNames(null);
131	}
132
133	put(Key.VERSION, version);
134	updateCapabilitesUrl();
135	}
136
137	/**
138	* @return transforms the settings to a String that can be stored in a
139	* .properties line. @see #parsePropertiesString
140	*/
141	public String toPropertiesString() {
142
143	StringBuffer serialized = new StringBuffer(100);
144
145	// BaseUrl
146	serialized.append(getBaseUrl().toString());
147	serialized.append(DELIMITER);
148
149	// Version
150	serialized.append(getVersion().toString());
151	serialized.append(DELIMITER);
152
153	return serialized.toString();
154	}
155
156	/**
157	* @return transforms the settings to a String that can be stored in a
158	* .properties line. @see #parsePropertiesString
159	* @throws MalformedURLException
160	*/
161	public static WfsServerSettings parsePropertiesString(String propString)
162	throws MalformedURLException {
163
164	String[] split = propString.split(Pattern.quote(DELIMITER));
165
166	// BaseUrl
167	URL baseUrl = new URL(split[0]);
168
169	// Version
170	WfsProtocollVersion v = WfsProtocollVersion.valueOf(split[1]);
171
172	return new WfsServerSettings(baseUrl, v);
173	}
174
175	@Override
176	public String toString() {
177	StringBuffer s = new StringBuffer();
178
179	URL baseUrl = getBaseUrl();
180	WfsProtocollVersion version = getVersion();
181
182	if (baseUrl != null)
183	s.append(baseUrl.toString() + " ");
184
185	if (version != null)
186	s.append(version.getVersionString());
187
188	return s.toString();
189	}
190
191	public void setCachedTypeNames(String[] cachedTypeNames) {
192	this.cachedTypeNames = cachedTypeNames;
193	}
194
195	public String[] getCachedTypeNames() {
196	return cachedTypeNames;
197	}
198
199	private String[] cachedTypeNames = null;
200
201	public String getTitle() {
202	// TODO
203	return "" + getBaseUrl() + " " + getVersion();
204	}
205
206	/**
207	* Opens a GUI that asks the use define a DB connection.
208	*
209	* @param wfsServer
210	* <code>null</code> to create a new instance, or an instance to
211	* edit.
212	* @return <code>null</code> if the user cancelled the creation of a new
213	* {@link DbServerSettings}, otherwise the edited instance.
214	*/
215	public static WfsServerSettings createOrEdit(Component owner,
216	WfsServerSettings wfsServer) {
217	boolean newCreated = false;
218
219	if (wfsServer == null) {
220	newCreated = true;
221	wfsServer = new WfsServerSettings();
222	}
223
224	Text hostInput = new ManualInputOption.Text(
225	"BaseURL (without any paramters)", true, wfsServer.getBaseUrl()
226	.toString());
227
228	Combo<WfsProtocollVersion> versionInput = new SelectionInputOption.Combo<WfsProtocollVersion>(
229	"WFS Version", true, WfsProtocollVersion.values(),
230	ArrayUtils.indexOf(WfsProtocollVersion.values(),
231	wfsServer.getVersion()), WfsProtocollVersion.values());
232
233	Object[] input = MultipleOptionPane.showMultipleInputDialog(owner,
234	"WFS Connection parameters", hostInput, versionInput);
235
236	if (input == null) {
237	if (newCreated)
238	return null;
239	else
240	return wfsServer;
241	} else {
242	wfsServer.setBaseUrl((String) input[0]);
243	wfsServer.setVersion(((WfsProtocollVersion) input[1]));
244	}
245
246	return wfsServer;
247
248	}
249
250	/**
251	* Set the BaseUrl as a String. Any pending parameters are automatically cut
252	* of.
253	*/
254	public void setBaseUrl(String urlString) {
255	try {
256	// Cutoff any parameters
257	if (urlString.indexOf("?") > -1) {
258	urlString = urlString.substring(0, urlString.indexOf("?"));
259	}
260
261	setBaseUrl(new URL(urlString));
262	} catch (MalformedURLException e) {
263	throw new RuntimeException(e);
264	}
265	}
266	}
Name	Value
svn:eol-style	native
svn:keywords	Id URL
svn:mime-type	text/plain