Mercurial > dive4elements > river

comparison flys-artifacts/src/main/java/org/dive4elements/river/utils/ArtifactMapfileGenerator.java @ 5831:bd047b71ab37

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Repaired internal references
author Sascha L. Teichmann <teichmann@intevation.de>
date Thu, 25 Apr 2013 12:06:39 +0200
parents flys-artifacts/src/main/java/de/intevation/flys/utils/ArtifactMapfileGenerator.java@b55975761708
children
comparison
equal deleted inserted replaced
5830:160f53ee0870 5831:bd047b71ab37
1 package org.dive4elements.river.utils;
2
3 import org.dive4elements.artifacts.CallContext;
4 import org.dive4elements.river.artifacts.FLYSArtifact;
5 import org.dive4elements.river.artifacts.access.RiverAccess;
6 import org.dive4elements.river.artifacts.model.LayerInfo;
7 import org.dive4elements.river.artifacts.model.map.WMSDBLayerFacet;
8 import org.dive4elements.river.artifacts.model.map.WMSLayerFacet;
9 import org.dive4elements.river.artifacts.model.map.WSPLGENLayerFacet;
10 import org.dive4elements.river.artifacts.resources.Resources;
11
12 import java.io.File;
13 import java.io.FileNotFoundException;
14 import java.io.IOException;
15 import java.util.List;
16
17 import org.apache.log4j.Logger;
18 import org.apache.velocity.Template;
19 import org.geotools.data.shapefile.ShpFiles;
20 import org.geotools.data.shapefile.shp.ShapefileHeader;
21 import org.geotools.data.shapefile.shp.ShapefileReader;
22
23 public class ArtifactMapfileGenerator extends MapfileGenerator {
24
25 private static Logger logger = Logger.getLogger(ArtifactMapfileGenerator.class);
26
27 @Override
28 protected String getVelocityLogfile() {
29 return FLYSUtils.getXPathString(FLYSUtils.XPATH_FLOODMAP_VELOCITY_LOGFILE);
30 }
31
32 @Override
33 protected String getMapserverTemplatePath() {
34 return FLYSUtils.getXPathString(FLYSUtils.XPATH_FLOODMAP_MAPSERVER_TEMPLATE_PATH);
35 }
36
37 @Override
38 public String getMapserverUrl() {
39 return FLYSUtils.getXPathString(FLYSUtils.XPATH_FLOODMAP_MAPSERVER_URL);
40 }
41
42 /**
43 * Method which starts searching for meta information file and mapfile
44 * generation.
45 */
46 @Override
47 public void generate() throws IOException
48 {
49 File[] userDirs = getUserDirs();
50 List<String> layers = parseLayers(userDirs);
51 logger.info("Found " + layers.size() + " layers for user mapfile.");
52
53 writeMapfile(layers);
54 }
55
56 /**
57 * Creates a layer file used for Mapserver's mapfile which represents the
58 * floodmap.
59 *
60 * @param flys The FLYSArtifact that owns <i>wms</i>.
61 * @param wms The WMSLayerFacet that contains information for the layer.
62 */
63 public void createUeskLayer(
64 FLYSArtifact flys,
65 WSPLGENLayerFacet wms,
66 String style,
67 CallContext context
68 ) throws FileNotFoundException, IOException
69 {
70 logger.debug("createUeskLayer");
71
72 LayerInfo layerinfo = new LayerInfo();
73 layerinfo.setName(MS_WSPLGEN_PREFIX + flys.identifier());
74 layerinfo.setType("POLYGON");
75 layerinfo.setDirectory(flys.identifier());
76 layerinfo.setData(WSPLGEN_RESULT_SHAPE);
77 layerinfo.setTitle(Resources.getMsg(Resources.getLocale(context.getMeta()),
78 "floodmap.uesk",
79 "Floodmap"));
80 layerinfo.setStyle(style);
81 RiverAccess access = new RiverAccess(flys);
82 String river = access.getRiver();
83 layerinfo.setSrid(FLYSUtils.getRiverDGMSrid(river));
84
85 String name = MS_LAYER_PREFIX + wms.getName();
86
87 Template template = getTemplateByName(WSPLGEN_LAYER_TEMPLATE);
88 if (template == null) {
89 logger.warn("Template '" + WSPLGEN_LAYER_TEMPLATE + "' found.");
90 return;
91 }
92
93 try {
94 File dir = new File(getShapefileBaseDir(), flys.identifier());
95 writeLayer(layerinfo, new File(dir, name), template);
96 }
97 catch (FileNotFoundException fnfe) {
98 logger.error(fnfe, fnfe);
99 logger.warn("Unable to write layer: " + name);
100 }
101 }
102
103
104 /**
105 * Creates a layer file used for Mapserver's mapfile which represents the
106 * user defined barriers.
107 *
108 * @param flys The FLYSArtifact that owns <i>wms</i>.
109 * @param wms The WMSLayerFacet that contains information for the layer.
110 */
111 public void createBarriersLayer(FLYSArtifact flys, WMSLayerFacet wms)
112 throws FileNotFoundException, IOException
113 {
114 logger.debug("createBarriersLayer");
115
116 //String uuid = flys.identifier();
117 //File dir = new File(getShapefileBaseDir(), uuid);
118
119 createBarriersLineLayer(flys, wms);
120 createBarriersPolygonLayer(flys, wms);
121 }
122
123
124 protected void createBarriersLineLayer(
125 FLYSArtifact flys,
126 WMSLayerFacet wms
127 )
128 throws FileNotFoundException, IOException
129 {
130 String uuid = flys.identifier();
131 String group = MS_BARRIERS_PREFIX + uuid;
132 String groupTitle = "I18N_BARRIERS_TITLE";
133
134 File dir = new File(getShapefileBaseDir(), uuid);
135 File test = new File(dir, WSPLGEN_LINES_SHAPE);
136
137 if (!test.exists() || !test.canRead()) {
138 logger.debug("No barrier line layer existing.");
139 return;
140 }
141
142 LayerInfo lineInfo = new LayerInfo();
143 lineInfo.setName(MS_LINE_PREFIX + uuid);
144 lineInfo.setType("LINE");
145 lineInfo.setDirectory(uuid);
146 lineInfo.setData(WSPLGEN_LINES_SHAPE);
147 lineInfo.setTitle("I18N_LINE_SHAPE");
148 lineInfo.setGroup(group);
149 lineInfo.setGroupTitle(groupTitle);
150 lineInfo.setSrid(wms.getSrid());
151
152 String nameLines = MS_LAYER_PREFIX + wms.getName() + "-lines";
153
154 Template tpl = getTemplateByName(SHP_LAYER_TEMPLATE);
155 if (tpl == null) {
156 logger.warn("Template '" + SHP_LAYER_TEMPLATE + "' found.");
157 return;
158 }
159
160 try {
161 writeLayer(lineInfo, new File(dir, nameLines), tpl);
162 }
163 catch (FileNotFoundException fnfe) {
164 logger.error(fnfe, fnfe);
165 logger.warn("Unable to write layer: " + nameLines);
166 }
167 }
168
169 protected void createBarriersPolygonLayer(
170 FLYSArtifact flys,
171 WMSLayerFacet wms
172 )
173 throws FileNotFoundException, IOException
174 {
175 String uuid = flys.identifier();
176 String group = uuid + MS_BARRIERS_PREFIX;
177 String groupTitle = "I18N_BARRIERS_TITLE";
178
179 File dir = new File(getShapefileBaseDir(), uuid);
180 File test = new File(dir, WSPLGEN_POLYGONS_SHAPE);
181
182 if (!test.exists() || !test.canRead()) {
183 logger.debug("No barrier line layer existing.");
184 return;
185 }
186
187 LayerInfo polygonInfo = new LayerInfo();
188 polygonInfo.setName(MS_POLYGONS_PREFIX + uuid);
189 polygonInfo.setType("POLYGON");
190 polygonInfo.setDirectory(uuid);
191 polygonInfo.setData(WSPLGEN_POLYGONS_SHAPE);
192 polygonInfo.setTitle("I18N_POLYGON_SHAPE");
193 polygonInfo.setGroup(group);
194 polygonInfo.setGroupTitle(groupTitle);
195 polygonInfo.setSrid(wms.getSrid());
196
197 String namePolygons = MS_LAYER_PREFIX + wms.getName() + "-polygons";
198
199 Template tpl = getTemplateByName(SHP_LAYER_TEMPLATE);
200 if (tpl == null) {
201 logger.warn("Template '" + SHP_LAYER_TEMPLATE + "' found.");
202 return;
203 }
204
205 try {
206 writeLayer(polygonInfo, new File(dir, namePolygons), tpl);
207 }
208 catch (FileNotFoundException fnfe) {
209 logger.error(fnfe, fnfe);
210 logger.warn("Unable to write layer: " + namePolygons);
211 }
212 }
213
214
215 /**
216 * Creates a layer file used for Mapserver's mapfile which represents the
217 * shape files uploaded by the user.
218 *
219 * @param flys The FLYSArtifact that owns <i>wms</i>.
220 * @param wms The WMSLayerFacet that contains information for the layer.
221 */
222 public void createUserShapeLayer(FLYSArtifact flys, WMSLayerFacet wms)
223 throws FileNotFoundException, IOException
224 {
225 logger.debug("createUserShapeLayer");
226
227 String uuid = flys.identifier();
228 File dir = new File(getShapefileBaseDir(), uuid);
229 File test = new File(dir, WSPLGEN_USER_SHAPE);
230
231 if (!test.exists() || !test.canRead()) {
232 logger.debug("No user layer existing.");
233 return;
234 }
235
236 File userShape = new File(dir, WSPLGEN_USER_SHAPE);
237 ShpFiles sf = new ShpFiles(userShape);
238 ShapefileReader sfr = new ShapefileReader(sf, true, false, null);
239 ShapefileHeader sfh = sfr.getHeader();
240
241 String group = uuid + MS_USERSHAPE_PREFIX;
242 String groupTitle = "I18N_USER_SHAPE_TITLE";
243
244 LayerInfo info = new LayerInfo();
245 info.setName(MS_USERSHAPE_PREFIX + uuid);
246 if (sfh.getShapeType().isLineType()) {
247 info.setType("LINE");
248 }
249 else if (sfh.getShapeType().isPolygonType()) {
250 info.setType("POLYGON");
251 }
252 else {
253 return;
254 }
255 info.setDirectory(uuid);
256 info.setData(WSPLGEN_USER_SHAPE);
257 info.setTitle("I18N_USER_SHAPE");
258 info.setGroup(group);
259 info.setGroupTitle(groupTitle);
260 info.setSrid(wms.getSrid());
261
262 String nameUser = MS_LAYER_PREFIX + wms.getName();
263
264 Template tpl = getTemplateByName(SHP_LAYER_TEMPLATE);
265 if (tpl == null) {
266 logger.warn("Template '" + SHP_LAYER_TEMPLATE + "' found.");
267 return;
268 }
269
270 try {
271 writeLayer(info, new File(dir, nameUser), tpl);
272 }
273 catch (FileNotFoundException fnfe) {
274 logger.error(fnfe, fnfe);
275 logger.warn("Unable to write layer: " + nameUser);
276 }
277
278 }
279
280
281 /**
282 * Creates a layer file used for Mapserver's mapfile which represents
283 * geometries from database.
284 *
285 * @param flys The FLYSArtifact that owns <i>wms</i>.
286 * @param wms The WMSLayerFacet that contains information for the layer.
287 */
288 public void createDatabaseLayer(
289 FLYSArtifact flys,
290 WMSDBLayerFacet wms,
291 String style
292 )
293 throws FileNotFoundException, IOException
294 {
295 logger.debug("createDatabaseLayer");
296
297 LayerInfo layerinfo = new LayerInfo();
298 layerinfo.setName(wms.getName() + "-" + flys.identifier());
299 layerinfo.setType(wms.getGeometryType());
300 layerinfo.setFilter(wms.getFilter());
301 layerinfo.setData(wms.getData());
302 layerinfo.setTitle(wms.getDescription());
303 layerinfo.setStyle(style);
304 if(wms.getExtent() != null) {
305 layerinfo.setExtent(GeometryUtils.jtsBoundsToOLBounds(wms.getExtent()));
306 }
307 layerinfo.setConnection(wms.getConnection());
308 layerinfo.setConnectionType(wms.getConnectionType());
309 layerinfo.setLabelItem(wms.getLabelItem());
310 layerinfo.setSrid(wms.getSrid());
311
312 String name = MS_LAYER_PREFIX + wms.getName();
313
314 Template template = getTemplateByName(DB_LAYER_TEMPLATE);
315 if (template == null) {
316 logger.warn("Template '" + DB_LAYER_TEMPLATE + "' found.");
317 return;
318 }
319
320 try {
321 File dir = new File(getShapefileBaseDir(), flys.identifier());
322 writeLayer(layerinfo, new File(dir, name), template);
323 }
324 catch (FileNotFoundException fnfe) {
325 logger.error(fnfe, fnfe);
326 logger.warn("Unable to write layer: " + name);
327 }
328 }
329
330 @Override
331 protected String getMapfilePath() {
332 return FLYSUtils.getXPathString(FLYSUtils.XPATH_FLOODMAP_MAPFILE_PATH);
333 }
334
335 @Override
336 protected String getMapfileTemplate() {
337 return FLYSUtils.getXPathString(FLYSUtils.XPATH_FLOODMAP_MAPFILE_TEMPLATE);
338 }
339
340 }
http://dive4elements.wald.intevation.org