Add GML32Parser test

52n-wps-io-geotools/src/main/java/org/n52/wps/io/datahandler/parser/GML32BasicParser.java

@@ -57,14 +57,12 @@
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 
 import javax.xml.namespace.QName;
 import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.parsers.SAXParserFactory;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.geotools.data.collection.ListFeatureCollection;
 import org.geotools.feature.FeatureCollection;
 import org.geotools.feature.FeatureIterator;
 import org.geotools.feature.GeometryAttributeImpl;
@@ -75,14 +73,18 @@
 import org.geotools.gml3.v3_2.GMLConfiguration;
 import org.geotools.xml.Configuration;
 import org.geotools.xml.Parser;
+import org.n52.wps.commons.WPSConfig;
 import org.n52.wps.io.SchemaRepository;
 import org.n52.wps.io.data.binding.complex.GTVectorDataBinding;
 import org.opengis.feature.GeometryAttribute;
 import org.opengis.feature.Property;
 import org.opengis.feature.simple.SimpleFeature;
+import org.opengis.feature.simple.SimpleFeatureType;
 import org.opengis.feature.type.GeometryDescriptor;
 import org.opengis.feature.type.GeometryType;
 import org.opengis.filter.identity.Identifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.xml.sax.SAXException;
 
 import com.vividsolutions.jts.geom.Geometry;
@@ -96,11 +98,26 @@ public class GML32BasicParser extends AbstractParser {
 
 	private static Logger LOGGER = LoggerFactory.getLogger(GML32BasicParser.class);
 	private Configuration configuration;
+	private boolean setParserNonStrict;
+	private boolean setBasicGMLConfiguration;
 
+
 
 	public GML32BasicParser() {
 		super();
 		supportedIDataTypes.add(GTVectorDataBinding.class);
+
+		org.n52.wps.PropertyDocument.Property[] properties = WPSConfig.getInstance().getPropertiesForParserClass(this.getClass().getCanonicalName());
+
+		for (org.n52.wps.PropertyDocument.Property property : properties) {
+                    if(property.getName().equals("setParserNonStrict")){
+                        setParserNonStrict = Boolean.parseBoolean(property.getStringValue());
+                    }else if(property.getName().equals("setBasicGMLConfiguration")){
+                        setBasicGMLConfiguration = Boolean.parseBoolean(property.getStringValue());
+                    }
+
+                }
+
 	}
 
 	public void setConfiguration(Configuration config) {
@@ -133,40 +150,52 @@ public GTVectorDataBinding parse(InputStream stream, String mimeType, String sch
 	}
 
 	public GTVectorDataBinding parse(InputStream input, QName schematypeTuple) {
+
+	    if(!setBasicGMLConfiguration){
+
 		if (configuration == null) {
 			configuration = resolveConfiguration(schematypeTuple);
 		}
-
+	    }else{
+	        configuration = new GMLConfiguration();
+	    }
 		Parser parser = new Parser(configuration);
-		parser.setStrict(true);
+
+		parser.setStrict(!setParserNonStrict);
 
 		//parse
-		FeatureCollection fc = resolveFeatureCollection(parser, input);
+		FeatureCollection<?, SimpleFeature> fc = resolveFeatureCollection(parser, input);
 
 		GTVectorDataBinding data = new GTVectorDataBinding(fc);
 
 		return data;
 	}
 
 
-	private FeatureCollection resolveFeatureCollection(Parser parser, InputStream input) {
-		FeatureCollection fc = null;
+	private FeatureCollection<?, SimpleFeature> resolveFeatureCollection(Parser parser, InputStream input) {
+		FeatureCollection<?, SimpleFeature> fc = null;
+		List<SimpleFeature> simpleFeatureList = new ArrayList<>();
 		try {
 			Object parsedData = parser.parse(input);
 			if (parsedData instanceof FeatureCollection){
-				fc = (FeatureCollection) parsedData;
+				fc = (FeatureCollection<?, SimpleFeature>) parsedData;
 			} else {
-				List<SimpleFeature> featureList = ((ArrayList<SimpleFeature>)((HashMap) parsedData).get("featureMember"));
-				if (featureList != null){
-					for( SimpleFeature feature : featureList){
-						fc.add(feature);
-					}
-				} else {
-					fc = (FeatureCollection) ((Map) parsedData).get("FeatureCollection");
+
+			    SimpleFeatureType featureType = null;
+				Object memberObject = ((HashMap<?, ?>) parsedData).get("member");
+
+				if(memberObject instanceof List<?>){
+	                            simpleFeatureList = ((ArrayList<SimpleFeature>)((HashMap<?, ?>) parsedData).get("member"));
+	                            featureType = simpleFeatureList.get(0).getFeatureType();
+				}else if(memberObject instanceof SimpleFeature){
+				    SimpleFeature simpleFeature = (SimpleFeature)((HashMap<?, ?>) parsedData).get("member");
+				    simpleFeatureList.add(simpleFeature);
+				    featureType = simpleFeature.getFeatureType();
 				}
+				fc = new ListFeatureCollection(featureType, simpleFeatureList);
 			}
 
-			FeatureIterator featureIterator = fc.features();
+			FeatureIterator<SimpleFeature> featureIterator = fc.features();
 			while (featureIterator.hasNext()) {
 				SimpleFeature feature = (SimpleFeature) featureIterator.next();
 

52n-wps-io-geotools/src/test/java/org/n52/wps/io/test/datahandler/parser/GML32BasicParserTest.java

@@ -0,0 +1,108 @@
+/**
+ * Copyright (C) 2007 - 2016 52°North Initiative for Geospatial Open Source
+ * Software GmbH
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published
+ * by the Free Software Foundation.
+ *
+ * If the program is linked with libraries which are licensed under one of
+ * the following licenses, the combination of the program with the linked
+ * library is not considered a "derivative work" of the program:
+ *
+ *       • Apache License, version 2.0
+ *       • Apache Software License, version 1.0
+ *       • GNU Lesser General Public License, version 3
+ *       • Mozilla Public License, versions 1.0, 1.1 and 2.0
+ *       • Common Development and Distribution License (CDDL), version 1.0
+ *
+ * Therefore the distribution of the program linked with libraries licensed
+ * under the aforementioned licenses, is permitted by the copyright holders
+ * if the distribution is compliant with both the GNU General Public
+ * License version 2 and the aforementioned licenses.
+ *
+ * As an exception to the terms of the GPL, you may copy, modify,
+ * propagate, and distribute a work formed by combining 52°North WPS
+ * GeoTools Modules with the Eclipse Libraries, or a work derivative of
+ * such a combination, even if such copying, modification, propagation, or
+ * distribution would otherwise violate the terms of the GPL. Nothing in
+ * this exception exempts you from complying with the GPL in all respects
+ * for all of the code used other than the Eclipse Libraries. You may
+ * include this exception and its grant of permissions when you distribute
+ * 52°North WPS GeoTools Modules. Inclusion of this notice with such a
+ * distribution constitutes a grant of such permissions. If you do not wish
+ * to grant these permissions, remove this paragraph from your
+ * distribution. "52°North WPS GeoTools Modules" means the 52°North WPS
+ * modules using GeoTools functionality - software licensed under version 2
+ * or any later version of the GPL, or a work based on such software and
+ * licensed under the GPL. "Eclipse Libraries" means Eclipse Modeling
+ * Framework Project and XML Schema Definition software distributed by the
+ * Eclipse Foundation and licensed under the Eclipse Public License Version
+ * 1.0 ("EPL"), or a work based on such software and licensed under the EPL.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+ * Public License for more details.
+ */
+package org.n52.wps.io.test.datahandler.parser;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+
+import org.n52.wps.io.data.binding.complex.GTVectorDataBinding;
+import org.n52.wps.io.datahandler.parser.GML32BasicParser;
+import org.n52.wps.io.test.datahandler.AbstractTestCase;
+
+public class GML32BasicParserTest extends AbstractTestCase<GML32BasicParser> {
+
+	public void testParser() {
+
+		if(!isDataHandlerActive()){
+			return;
+		}
+
+		String testFilePath = projectRoot
+				+ "/52n-wps-io-geotools/src/test/resources/tasmania_roads_gml32.xml";
+
+		try {
+			testFilePath = URLDecoder.decode(testFilePath, "UTF-8");
+		} catch (UnsupportedEncodingException e1) {
+			e1.printStackTrace();
+			fail(e1.getMessage());
+		}
+
+//		String[] mimetypes = theParser.getSupportedFormats();
+
+		InputStream input = null;
+
+		try {
+			input = new FileInputStream(new File(testFilePath));
+		} catch (FileNotFoundException e) {
+			fail(e.getMessage());
+		}
+
+		// for (String mimetype : mimetypes) {
+
+		GTVectorDataBinding theBinding = dataHandler.parse(input,
+				"text/xml; subtype=gml/3.2.1",
+				"http://schemas.opengis.net/gml/3.2.1/base/feature.xsd");
+
+		assertNotNull(theBinding.getPayload());
+		assertTrue(theBinding.getPayloadAsShpFile().exists());
+		assertTrue(!theBinding.getPayload().isEmpty());
+
+		// }
+
+	}
+
+	@Override
+	protected void initializeDataHandler() {
+		dataHandler = new GML32BasicParser();
+	}
+
+}