dive4elements/gnv-client: gnv-artifacts/src/main/java/de/intevation/gnv/state/layer/LayerOutputState.java comparison

comparison gnv-artifacts/src/main/java/de/intevation/gnv/state/layer/LayerOutputState.java @ 859:3fbabd4803d7

ISSUE252 Make it possible to export more than one Layer gnv-artifacts/trunk@983 c6561f87-3c4e-4783-a992-168aeb5c3f6f

author	Tim Englich <tim.englich@intevation.de>
date	Mon, 26 Apr 2010 09:09:20 +0000
parents	164d102b0af5
children	dfd02f8d3602

comparison

equal deleted inserted replaced

-:ec2265bb85a1
+:3fbabd4803d7
 package de.intevation.gnv.state.layer;
 import java.io.File;
 import java.io.IOException;
 import java.io.OutputStream;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 import org.apache.log4j.Logger;
 import org.w3c.dom.Document;
-import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 import com.vividsolutions.jts.geom.Geometry;
 import com.vividsolutions.jts.io.ParseException;
 import com.vividsolutions.jts.io.WKTReader;
 public static final String LAYER_MODEL    = "layer";
 /**
 * The Name of the Shapefile which will be generated.
 */
-public static final String SHAPEFILE_NAME   = "data.shp";
+public static final String SHAPEFILE_NAME   = "data";
 /**
 * The ID for the Query fetching the Layer from the DB
 */
 private String dataQueryID = null;
 /**
 * The Path where the Shapefile is stored.
 */
 private String shapeFilePath;
-/**
-* The ID of the Template which should be used to generate the Layerentry
-* in the Mapfile.
-*/
-private String templateID = null;
-/**
-* The Kind of Geometry which should be used to generate the Shapefile.
-*/
-private String geometryType = null;
 /**
 * Constructor
 */
 public LayerOutputState() {
 }
 public void out(Document format, Collection<InputData> inputData,
 OutputStream outputStream, String uuid,
 CallContext callContext) throws StateException {
 log.debug("LayerOutputState.out");
 String outputMode = XMLUtils.xpathString(
 format, XPATH_OUTPUT_MODE, ArtifactNamespaceContext.INSTANCE);
 if (outputMode.equalsIgnoreCase("wms")) {
-Collection<Result> data = this.fetchData();
-if (data != null && !data.isEmpty()){
+Collection<LayerMetaData> layerMetaData =
+this.getRequestedLayerMetadata();
+if (layerMetaData != null && !layerMetaData.isEmpty()){
 XMLUtils.toStream(this.getWMS(uuid, callContext,
-data, geometryType,
+layerMetaData,inputData),
-inputData),
 outputStream);
 }else{
 this.writeExceptionReport2Stream(outputStream);
 }
 }else if (outputMode.equalsIgnoreCase("zip")){
-Collection<Result> data = this.fetchData();
+Collection<LayerMetaData> layerMetaData =
-if (data != null && !data.isEmpty()){
+this.getRequestedLayerMetadata();
-this.writeZip(uuid, callContext, outputStream,
-data,geometryType);
+if (layerMetaData != null && !layerMetaData.isEmpty()){
+this.writeZip(uuid, callContext,
+outputStream, layerMetaData);
 }else{
 this.writeExceptionReport2Stream(outputStream);
 }
 }
 ArtifactXMLUtilities.
 createExceptionReport("No Data to Export", document);
 XMLUtils.toStream(document,outputStream);
 }
+/**
-/**
+* Returns the Metadata for the requested Layers for fetching the data
-* Fetches the Data from the Databasebackend.
+* of the Layer and generating the Layer and WMS.
-*
+* @return the Metadata for the requested Layers
-* @return the resultdata.
+*/
-*/
+private Collection<LayerMetaData> getRequestedLayerMetadata(){
-protected Collection<Result> fetchData(){
+log.debug("LayerOutputState.getRequestedLayerMetadata");
-log.debug("LayerOutputState.fetchData");
 Collection<Result> result = this.getData(this.queryID);
-Collection<Result> data = null;
+Collection<LayerMetaData> returnValue = null;
-String geometryWKT = null;
 if (result != null){
 QueryExecutor queryExecutor = QueryExecutorFactory.getInstance()
 .getQueryExecutor();
 Iterator<Result> it = result.iterator();
-String[] queryValues = null;
+returnValue = new ArrayList<LayerMetaData>(result.size());
-if (it.hasNext()){
+while (it.hasNext()){
 Result resultValue = it.next();
 String table = resultValue.getString(0);
+String geometryType = this.getGeometryType(table, queryExecutor);
-this.geometryType = this.getGeometryType(table, queryExecutor);
 String where = resultValue.getString(1);
 String columns = this.fetchColumns(table);
+String templateID = resultValue.getString(2);
-templateID = resultValue.getString(2);
+String[] queryValues = null;
+String geometryWKT = null;
 if (this.geometryID != null){
 InputData geometryInputData =
 this.inputData.get(this.geometryID);
 if (geometryInputData != null){
 try {
 Collection<Result> geometryData = queryExecutor
 .executeQuery(this.geometryQueryID,
 new String[]{geometryInputData.getValue()});
 Iterator<Result> git = geometryData.iterator();
 if (git.hasNext()){
 geometryWKTData.getValue()};
 }else{
 queryValues = new String[]{columns,table,where};
 }
 }
-}
+returnValue.add(new LayerMetaData(table, geometryType,
+where, columns,
-try {
+templateID, queryValues,
-data  = queryExecutor.executeQuery(dataQueryID,
+geometryWKT));
-queryValues);
+}
-if (data != null && geometryWKT != null){
+}
-WKTReader wktReader = new WKTReader();
+return returnValue;
-Geometry border = wktReader.read(geometryWKT);
+}
-Iterator<Result> dataIt = data.iterator();
+/**
-while (dataIt.hasNext()){
+* Fetches the Data from the Databasebackend.
-// Trim the Geometries using the
+*
-// Geometry if on is available.
+* @return the resultdata.
-Result current = dataIt.next();
+*/
-String currentWKT = current.getString(0);
+protected Collection<Result> fetchData(LayerMetaData layerMetaData){
-Geometry currentGeometry = null;
+log.debug("LayerOutputState.fetchData");
-try {
+Collection<Result> data = null;
-currentGeometry = wktReader.read(currentWKT);
+QueryExecutor queryExecutor = QueryExecutorFactory.getInstance()
-} catch (Exception e) {
+.getQueryExecutor();
-log.error("Error parsing Geometry "+ currentWKT);
+try {
-log.error(e,e);
+data  = queryExecutor.executeQuery(dataQueryID,
-}
+layerMetaData.getQueryValues());
+if (data != null && layerMetaData.getGeometryWKT() != null){
-if (currentGeometry != null){
+WKTReader wktReader = new WKTReader();
-Geometry newGeometry = currentGeometry.intersection(border);
+Geometry border = wktReader.read(layerMetaData.getGeometryWKT());
-current.addColumnValue(0, newGeometry.toText());
+Iterator<Result> dataIt = data.iterator();
-}
+while (dataIt.hasNext()){
-}
+// Trim the Geometries using the
-}
+// Geometry if one is available.
-} catch (QueryException e) {
+Result current = dataIt.next();
-log.error(e,e);
+String currentWKT = current.getString(0);
-} catch (ParseException e){
+Geometry currentGeometry = null;
-log.error(e,e);
+try {
-}
+currentGeometry = wktReader.read(currentWKT);
+} catch (Exception e) {
+log.error("Error parsing Geometry "+ currentWKT);
+log.error(e,e);
+}
+if (currentGeometry != null){
+Geometry newGeometry = currentGeometry.intersection(border);
+current.addColumnValue(0, newGeometry.toText());
+}
+}
+}
+} catch (QueryException e) {
+log.error(e,e);
+} catch (ParseException e){
+log.error(e,e);
 }
 return data;
 }
 private String getGeometryType(String tableName,
 QueryExecutor queryExecutor){
 String returnValue = null;
 String[] tables = tableName.toUpperCase().split(",");
 String[] filter = tables[0].split("\\.");
 try {
 Collection<Result> result =
 queryExecutor.executeQuery(this.geometryTypeQueryID, filter);
 if (result != null && !result.isEmpty())
 {
 }
 }
 } catch (QueryException e) {
 log.error(e,e);
 }
 return returnValue;
 }
 /**
 try {
 String[] tables = tableName.toUpperCase().split(",");
 String[] filter = tables[0].split("\\.");
 // Only use the first Table the second one will be ignored.
 QueryExecutor queryExecutor = QueryExecutorFactory.getInstance()
 .getQueryExecutor();
 Collection<Result> columnData = queryExecutor.
 executeQuery(this.columnQueryID,
 filter);
 if (columnData != null && !columnData.isEmpty()){
 StringBuffer sb = new StringBuffer();
 }
 }
 }
 returnValue = sb.toString();
 }
 } catch (QueryException e) {
 log.error(e,e);
 }
 return returnValue;
 }
 */
 protected String writeToShapeFile(
 String             uuid,
 Collection<Result> data,
 CallContext        callContext,
-String geometryType
+String geometryType,
+int layerNumber
 ) {
-File baseDir = shapefileDirectory(callContext);
+boolean success    = false;
+if (data != null && !data.isEmpty()){
+File shapeDir = new File(shapeFilePath);
+try {
+File shapeFile = new File(shapeDir, createShapeFileName(layerNumber));
+if (!ShapeFileWriter.writeDataToFile(shapeFile, "data", data,geometryType)){
+log.error("writing data into shapefile failed");
+return null;
+}
+success = true;
+callContext.afterCall(CallContext.STORE);
+return shapeFilePath;
+}
+finally {
+if (!success) {
+FileUtils.deleteRecursive(shapeDir);
+}
+}
+}else{
+return null;
+}
+}
+/**
+* Check if the ShapeDir exists and if it exists delete all Contents
+* in it. If it not exists the Director will be created.
+* @param baseDir the BaseDirectory for all ShapeDirs
+* @param uuid the UUID  which is used to create the Directory
+* @return true if the directory exists or could be created.
+*         false if the directory could not be created.
+*/
+private boolean createShapeDir(File baseDir, String uuid){
 File shapeDir = new File(baseDir, uuid);
-boolean success    = false;
 boolean createdDir = false;
+synchronized (shapeFileLock) {
-try {
+if (shapeDir.exists()) {
-synchronized (shapeFileLock) {
+FileUtils.deleteContent(shapeDir); // TODO Place on getZip and getWMS
-if (shapeDir.exists()) {
+}
-FileUtils.deleteContent(shapeDir);
+else if (!shapeDir.mkdirs()) {
-}
+log.error("cannot create directory '"
-else if (!shapeDir.mkdirs()) {
++ shapeDir.getAbsolutePath() + "'");
-log.error("cannot create directory '"
+return false;
-+ shapeDir.getAbsolutePath() + "'");
+}
-return null;
+createdDir = true;
 }
-createdDir = true;
+shapeFilePath = shapeDir.getAbsolutePath();
-}
+return createdDir;
+}
-File shapeFile = new File(shapeDir, SHAPEFILE_NAME);
-if (!ShapeFileWriter.writeDataToFile(shapeFile, "data", data,geometryType)){
-log.error("writing data into shapefile failed");
-return null;
-}
-shapeFilePath = shapeDir.getAbsolutePath();
-success = true;
-callContext.afterCall(CallContext.STORE);
-return shapeFilePath;
-}
-finally {
-if (!success && createdDir) {
-FileUtils.deleteRecursive(shapeDir);
-}
-}
-}
 /**
 * Create a zip archive with the shapefiles of the given shapefiles path and
 * write it to <code>output</code>.
 *
 */
 protected void writeZip(
 String       uuid,
 CallContext  callContext,
 OutputStream output,
-Collection<Result> data,
+Collection<LayerMetaData> layerMetaData
-String geometryType
 )
 throws StateException
 {
 try {
 String p = getShapeFilePath();
 if (dir.isDirectory()) {
 FileUtils.createZipArchive(dir, output);
 }
 }
 else {
+File baseDir = shapefileDirectory(callContext);
-if ((p = writeToShapeFile(uuid, data, callContext,geometryType)) != null) {
+if (!this.createShapeDir(baseDir, uuid)){
+return;
+}
+Iterator<LayerMetaData> it = layerMetaData.iterator();
+int i = 1;
+while(it.hasNext()){
+LayerMetaData lmd = it.next();
+Collection<Result> data = this.fetchData(lmd);
+p = writeToShapeFile(uuid, data, callContext,lmd.getGeometryType(),i++);
+}
+if (p != null) {
 FileUtils.createZipArchive(new File(p), output);
 }
 }
 }
 catch (IOException ioe) {
 synchronized (shapeFileLock) {
 return shapeFilePath;
 }
 }
+/**
+* Returns the basic-directory where the Shapefiles should be placed in.
+* @param callContext the Context of this Call
+* @return the Directory where the Shapefiles could be placed in.
+*         (Please create an own directory in this dir and not put the
+*          Files directly in it)
+*/
 private static File shapefileDirectory(CallContext callContext) {
-// TODO: Refactoring nessessary it should be used only one Shapefilepath
+// Code was taken from HorizontalCrossSectionMeshOutputState
-//       for alle Modes. Code was taken from HorizontalCrossSectionMeshOutputState
 GNVArtifactContext context =
 (GNVArtifactContext)callContext.globalContext();
 File dir = (File)context.get(
 GNVArtifactContext.HORIZONTAL_CROSS_SECTION_RESULT_SHAPEFILE_PATH_KEY);
 return dir != null
 @Override
 public void endOfLife(Object globalContext) {
 super.endOfLife(globalContext);
 // do it in background
 new Thread() {
 @Override
 public void run() {
 String path = resetShapeFilePath();
 if (path == null) {
 return;
 }
 File dir = new File(path);
 for (int i = 0; i < 10; ++i) {
 if (!dir.exists() || FileUtils.deleteRecursive(dir)) {
 MapfileGenerator.getInstance().update();
 return;
 }
 try {
 Thread.sleep(10000L);
 }
 catch (InterruptedException ie) {
 }
 */
 private String resetShapeFilePath() {
 synchronized (shapeFileLock) {
 String path = shapeFilePath;
 shapeFilePath = null;
-templateID = null;
 return path;
 }
 }
 * these shapefiles. The map service can be queried for displaying
 * corresponding layers as WMS.
 *
 * @param uuid The UUID of the current artifact.
 * @param callContext The CallContext object.
-* @param data A collection with some input data.
+* @param layerMetaData The Metadata which is required to create the
-* @param geometryType The geometry type.
+*                      different Layers.
 * @param inputData the Parameters which are send by the out-Call.
 * @return a document with some meta information (shapefile path, geometry
 * type, time to live of the current artifact, etc).
 * @throws StateException if an error occured while shapefile writing.
 */
 protected Document getWMS(String uuid,
 CallContext callContext,
-Collection<Result> data,
+Collection<LayerMetaData> layerMetaData,
-String geometryType,
 Collection<InputData> inputData)
 throws StateException
 {
+String path = getShapeFilePath();
+if (path != null &&  new File(path).isDirectory()){
+return this.refreshMetaFile(layerMetaData, inputData,
+uuid, callContext);
+}else{
+Document document = XMLUtils.newDocument();
+if (this.shapeFilePath == null){
+File baseDir = shapefileDirectory(callContext);
+if (!this.createShapeDir(baseDir, uuid)){
+// TODO Insert Error Report
+return document;
+}
+}
+path = getShapeFilePath();
+Iterator<LayerMetaData> it = layerMetaData.iterator();
+Node meta = null;
+int layerNumber = 0;
+while (it.hasNext()){
+LayerMetaData lmd = it.next();
+layerNumber ++;
+String geometryType = lmd.getGeometryType();
+String templateId = lmd.getTemplateID();
+ExclusiveExec.UniqueKey key = ExclusiveExec.INSTANCE.acquire(uuid);
+try{
+Collection<Result> data = this.fetchData(lmd);
+if (data != null &&
+(this.writeToShapeFile(uuid, data, callContext,
+geometryType,layerNumber)) != null) {
+String paramType = findParameterTitle(geometryType,templateId);
+String    title      = getLayerTitle(inputData);
+if (title == null) {
+title = uuid+"_"+layerNumber;
+}else{
+title = title+"_"+layerNumber;
+}
+if (meta == null){
+meta = MetaWriter.writeLayerMeta(callContext,document);
+}
+MetaWriter.writeLayerMeta(callContext, document,
+meta, uuid, paramType,
+this.determineGeometryType(geometryType),
+createShapeFileName(layerNumber),
+title);
+}
+if (meta != null && !it.hasNext()) {
+MetaWriter.writeMetaFile(path,document);
+MapfileGenerator.getInstance().update();
+return document;
+}
+}finally{
+ExclusiveExec.INSTANCE.release(key);
+}
+}
+return document;
+}
+}
+/**
+* Creates the name of the Shapefile
+* @param layerNumber the Number of the Layer
+* @return the create name of the Shapefile.
+*/
+private String createShapeFileName(int layerNumber) {
+return SHAPEFILE_NAME+"_"+layerNumber+".shp";
+}
+/**
+* Method that refreshes the Metadatafile for publishing the WMS
+* Without generating the Data ones again.
+* @param layerMetaData the Metadata which is required to create the Layers
+* @param inputData the Inputdata which was sent by the Client
+* @param uuid the uuid of the Artifact
+* @param callContext the context of this Call
+* @return a refreshed Metadata-Document
+*/
+private Document refreshMetaFile(Collection<LayerMetaData> layerMetaData,
+Collection<InputData> inputData,
+String uuid,
+CallContext callContext){
 Document document = XMLUtils.newDocument();
+Node meta = null;
-Element pathElement = document.createElement("path");
+int layerNumber = 0;
-document.appendChild(pathElement);
+Iterator<LayerMetaData> it = layerMetaData.iterator();
+while (it.hasNext()){
-String path = getShapeFilePath();
+LayerMetaData lmd = it.next();
+layerNumber ++;
-if (path != null && new File(path).isDirectory()) {
+String geometryType = lmd.getGeometryType();
+String templateId = lmd.getTemplateID();
 String title = getLayerTitle(inputData);
 if (title == null) {
-title = uuid;
+title = uuid+"_"+layerNumber;
-}
+}else{
+title = title+"_"+layerNumber;
+}
 callContext.putContextValue(
 MetaWriter.CONTEXT_LAYER_TITLE, title);
+String paramType = findParameterTitle(geometryType,templateId);
-String paramType = findParameterTitle(geometryType);
 if (log.isDebugEnabled()) {
 log.debug("Layer title: " + title);
 log.debug("Layer type: " + paramType);
 }
+if (meta == null){
-Document meta = MetaWriter.writeLayerMeta(callContext, uuid,
+meta = MetaWriter.writeLayerMeta(callContext,document);
-path, paramType,
+}
-this.determineGeometryType(geometryType),
+MetaWriter.writeLayerMeta(callContext, document,
-SHAPEFILE_NAME,
+meta, uuid, paramType,
-title);
+this.determineGeometryType(geometryType),
-if (meta != null) {
+createShapeFileName(layerNumber),
+title);
+if (meta != null && !it.hasNext()) {
+MetaWriter.writeMetaFile(getShapeFilePath(),document);
 MapfileGenerator.getInstance().update();
-return meta;
+return document;
 }
+}
-pathElement.setTextContent(path);
-}
-else {
-ExclusiveExec.UniqueKey key = ExclusiveExec.INSTANCE.acquire(uuid);
-try{
-if (data != null &&
-(path = writeToShapeFile(uuid, data, callContext,geometryType)) != null) {
-String paramType = findParameterTitle(geometryType);
-String    title      = getLayerTitle(inputData);
-if (title == null) {
-title = uuid;
-}
-Document meta = MetaWriter.writeLayerMeta(callContext, uuid,
-path, paramType,
-this.determineGeometryType(geometryType),
-SHAPEFILE_NAME,
-title);
-if (meta != null) {
-MapfileGenerator.getInstance().update();
-return meta;
-}
-pathElement.setTextContent(path);
-}
-}finally{
-ExclusiveExec.INSTANCE.release(key);
-}
-}
 return document;
 }
 /**
 * Returns the parameterType for the Layer.
 * @param geometryType
 * @return
 */
-private String findParameterTitle(String geometryType) {
+private String findParameterTitle(String geometryType, String templateID) {
 String paramType = LAYER_MODEL+"_"+templateID;
 if (!MapfileGenerator.getInstance().templateExists(paramType)){
 // If the template doesn't exist the Defaulttemplates will be used.
 paramType = LAYER_MODEL+"_"+
 this.determineDefaultTemplateName(geometryType);
 }
 *
 * @param geometryType The original geometry type.
 * @return a valid geometry type fpr the template mechanism.
 */
 private String determineGeometryType(String geometryType){
 String returnValue = geometryType.toLowerCase();
 if (returnValue.equalsIgnoreCase("linestring")){
 returnValue = "Line";
 }else if (returnValue.equalsIgnoreCase("multilinestring")){
 returnValue ="Line";
 }else if (returnValue.equalsIgnoreCase("multipolygon")){
 *
 * @param geometryType The geometry type.
 * @return a default geometry fitting to the original geometry type.
 */
 private String determineDefaultTemplateName(String geometryType){
 String returnValue = geometryType.toLowerCase();
 if (returnValue.equalsIgnoreCase("multilinestring")){
 returnValue ="linestring";
 }else if (returnValue.equalsIgnoreCase("multipolygon")){
 returnValue = "polygon";
 }else if (returnValue.equalsIgnoreCase("multipoint")){

Mercurial > dive4elements > gnv-client

comparison gnv-artifacts/src/main/java/de/intevation/gnv/state/layer/LayerOutputState.java @ 859:3fbabd4803d7