querybuildertaskaimsutil.java

esri的ArcGIS Server超级学习模板程序（for java）

package com.esri.solutions.jitk.web.tasks.query.querybuilder;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;

import com.esri.adf.web.aims.data.AIMSMapFunctionality;
import com.esri.adf.web.aims.data.AIMSMapResource;
import com.esri.adf.web.aims.data.query.AIMSQueryFunctionality;
import com.esri.adf.web.data.WebLayerInfo;
import com.esri.adf.web.data.geometry.WebExtent;
import com.esri.adf.web.data.geometry.WebGeometry;
import com.esri.adf.web.data.geometry.WebPath;
import com.esri.adf.web.data.geometry.WebPoint;
import com.esri.adf.web.data.geometry.WebPolygon;
import com.esri.adf.web.data.geometry.WebPolyline;
import com.esri.adf.web.data.geometry.WebRing;
import com.esri.adf.web.data.query.QueryResult;
import com.esri.adf.web.data.query.WebQuery;
import com.esri.aims.mtier.model.acetate.Path;
import com.esri.aims.mtier.model.acetate.Point;
import com.esri.aims.mtier.model.acetate.Points;
import com.esri.aims.mtier.model.acetate.Polygon;
import com.esri.aims.mtier.model.acetate.Polyline;
import com.esri.aims.mtier.model.acetate.Ring;
import com.esri.aims.mtier.model.acetate.Shape;
import com.esri.aims.mtier.model.envelope.Envelope;
import com.esri.aims.mtier.model.map.Layers;
import com.esri.aims.mtier.model.map.Map;
import com.esri.aims.mtier.model.map.layer.FeatureLayer;
import com.esri.aims.mtier.model.map.layer.Layer;
import com.esri.aims.mtier.model.map.layer.query.Filter;
import com.esri.aims.mtier.model.map.layer.query.Geometry;
import com.esri.aims.mtier.model.map.layer.query.Records;
import com.esri.aims.mtier.model.map.layer.query.Recordset;
import com.esri.aims.mtier.model.map.layer.query.TableDesc;

/**
 * This utility class returns selected ArcIMS information. 
 */
public class QueryBuilderTaskAimsUtil{
	
	private static Logger logger = LogManager.getLogger(QueryBuilderTaskAimsUtil.class.getName());

	public static LinkedHashMap<String, String> getAimsFieldList(Object resource, String id, int lyrId) {
		
		if(resource != null && resource instanceof AIMSMapResource) {
			try {
				AIMSMapFunctionality mapFunc = (AIMSMapFunctionality)((AIMSMapResource)resource).getFunctionality(AIMSMapFunctionality.FUNCTIONALITY_NAME);
				Layers layers = mapFunc.getMap().getLayers();
				String chkLyrId = (lyrId >= 0 && lyrId < layers.getCount()) ? layers.item(lyrId).getID() : null;
				Layer layer = mapFunc.getLayer(chkLyrId);
				
				LinkedHashMap<String, String> fieldList = new LinkedHashMap<String, String>();
				
				if(layer instanceof FeatureLayer) {
					TableDesc tableDesc = ((FeatureLayer)layer).getRecordset().getTableDesc();
					
					for (int i = 0; i < tableDesc.getCount(); i++) {
						if(!tableDesc.getFieldName(i).equalsIgnoreCase("#SHAPE#")) {
							fieldList.put(tableDesc.getFieldName(i) + "!" + tableDesc.getFieldType(i), tableDesc.getFieldName(i));
						}
					}
					
					return fieldList;
				}
			
			} catch(Exception e) {
				logger.warn("Unable to get aims field list", e);
			}
		}
		
		return null;
	}

	private static Shape toAIMSGeometry(WebGeometry webGeometry) {
		
		try {
			if(webGeometry instanceof WebPoint) {
				WebPoint webPoint = (WebPoint)webGeometry;
				Point point = new Point();
				point.setX(webPoint.getX());
				point.setY(webPoint.getY());
				
				return point;
			
			} else if(webGeometry instanceof WebPolyline) {
				WebPolyline webPolyline = (WebPolyline)webGeometry;
				Polyline polyline = new Polyline();
				List<WebPath> webPaths = webPolyline.getPaths();
				Iterator<WebPath> it = webPaths.iterator();
				
				while(it.hasNext()) {
					WebPath webPath = (WebPath)it.next();
					List<WebPoint> webPoints = webPath.getPoints();
					Iterator<WebPoint> pit = webPoints.iterator();
					Points points = new Points();
					
					while(pit.hasNext()) {
						WebPoint webPoint = (WebPoint)pit.next();
						Point point = new Point();
						point.setX(webPoint.getX());
						point.setY(webPoint.getY());
						points.addPointObject(point);
					}
					
					Path path = new Path();
					path.setPoints(points);
					polyline.addPath(path);
				}
				
				return (Shape)polyline;
			
			} else if(webGeometry instanceof WebPolygon) {
				WebPolygon webPolygon = (WebPolygon)webGeometry;
				Polygon polygon = new Polygon();
				List<WebRing> webRings = webPolygon.getRings();
				Iterator<WebRing> it = webRings.iterator();
				
				while(it.hasNext()) {
					WebRing webRing = (WebRing)it.next();
					List<WebPoint> webPoints = webRing.getPoints();
					Iterator<WebPoint> pit = webPoints.iterator();
					Points points = new Points();
					
					while(pit.hasNext()) {
						WebPoint webPoint = (WebPoint)pit.next();
						Point point = new Point();
						point.setX(webPoint.getX());
						point.setY(webPoint.getY());
						points.addPointObject(point);
					}
					
					Ring ring = new Ring();
					ring.setPoints(points);
					polygon.addRing(ring);
				}
				
				return (Shape)polygon;
			
			} else if (webGeometry instanceof WebExtent) {
				WebExtent webExtent = (WebExtent)webGeometry;
				Envelope envelope = new Envelope();
				envelope.setMinX(webExtent.getMinX());
				envelope.setMinY(webExtent.getMinY());
				envelope.setMaxX(webExtent.getMaxX());
				envelope.setMaxY(webExtent.getMaxY());
				
				return (Shape)envelope;
			}
			
		} catch(Exception e) {
			logger.warn("Unable to convert WebGeometry to aims geometry", e);
		}
		
		return null;
	}

	private static WebGeometry toWebGeometry(Geometry geometry) {
		
		try {
			Points points = geometry.getPoints();
			
			if (points.getCount() == 1) {
				WebPoint webPoint = new WebPoint();
				Point point = points.getPointObject(0);
				webPoint.setX(point.getX());
				webPoint.setY(point.getY());
				
				return (WebGeometry)webPoint;
			
			} else if(points.getCount() > 1) {
				Point point1 = points.getPointObject(0);
				Point point2 = points.getPointObject(points.getCount() - 1);
				boolean isPolygon = false;
				
				if(point1.getX() == point2.getX() && point1.getY() == point2.getY()) {
					isPolygon = true;
				}
				
				if (isPolygon) {
					WebRing webRing = new WebRing();
					
					for(int i = 0; i < points.getCount(); i++){
						Point point = points.getPointObject(i);
						WebPoint webPoint = new WebPoint();
						webPoint.setX(point.getX());
						webPoint.setY(point.getY());
						webRing.addPoint(webPoint);
					}
					WebPolygon webPolygon = new WebPolygon();
					webPolygon.addRing(webRing);
					
					return (WebGeometry)webPolygon;
				
				} else {
					WebPath webPath = new WebPath();
					for (int i = 0; i < points.getCount(); i++){
						Point point = points.getPointObject(i);
						WebPoint webPoint = new WebPoint();
						webPoint.setX(point.getX());
						webPoint.setY(point.getY());
						webPath.addPoint(webPoint);
					}
					WebPolyline webPolyline = new WebPolyline();
					webPolyline.addPath(webPath);
					
					return (WebGeometry)webPolyline;
				}
			}
		} catch(Exception e) {
			logger.warn("Unable to convert aims geometry to WebGeometry", e);
		}
		
		return null;
	}

	public static List<QueryResult> doQuery(Object resource, WebQuery webQuery, QueryBuilderCriteria qbc, WebLayerInfo webLayerInfo){
		List<QueryResult> results = new ArrayList<QueryResult>();
		
		try {
			String lyrId = qbc.getLayerId();
			if (!(resource instanceof AIMSMapResource)) return null;

			AIMSMapResource aimsMapResource = (AIMSMapResource)resource;
			AIMSMapFunctionality aimsMapFunc = (AIMSMapFunctionality)(aimsMapResource).getFunctionality(AIMSMapFunctionality.FUNCTIONALITY_NAME);
			Map aimsMap = aimsMapFunc.getMap();
			aimsMap.getLayers().setGeometry(true);
			Layer aimsLayer = aimsMapFunc.getLayer(lyrId);
			
			if(aimsLayer instanceof FeatureLayer) {
				FeatureLayer fLayer = (FeatureLayer)aimsLayer;
				Filter filter = new Filter();
				filter.setWhereExpression(qbc.getWhereClause());
				filter.setSpatialShape(toAIMSGeometry(qbc.getWebGeometry()));
				fLayer.setFilterObject(filter);
				Recordset recordset = fLayer.getRecordset();
				TableDesc tableDesc = recordset.getTableDesc();
				
				for(int i = 0; i < recordset.getCount(); i++) {
					Records record = recordset.getRecords(i);
					java.util.Map<String, Object> details = new LinkedHashMap<String, Object>();
					WebGeometry adfGeom = null;
					if (recordset.getGeometryCount() > 0) adfGeom = toWebGeometry(recordset.getGeometry(i));
					String displayName = "record:" + i;
					
					for(int j = 0; j < tableDesc.getCount(); j++) {
						details.put(tableDesc.getFieldName(j), record.getFieldValue(j));
					}
					
					QueryResult queryResult = new QueryResult(webLayerInfo, displayName, webQuery, details, null, adfGeom);
					results.add(queryResult);
				}
/*
				fLayer.getRecordset().clearRecordset();
				fLayer.getRecordset().clearEnvelope();
				fLayer.getRecordset().clearGeometry();
				fLayer.setFilterObject(null);
 */
			}
			
			aimsMap.refresh();
		
		} catch (Exception e) {
			logger.warn("Unable to do query", e);
		}
		
		return results;
	}
	
	public static LinkedHashMap<String, String> getServiceLayerList(AIMSMapResource aimsMapResource, String resourceId){
		
		try {
			LinkedHashMap<String, String> newLayerList = new LinkedHashMap<String, String>();	
			
			if(aimsMapResource != null) {
				AIMSQueryFunctionality qfunc = (AIMSQueryFunctionality)aimsMapResource.getFunctionality(AIMSQueryFunctionality.FUNCTIONALITY_NAME);
				
				if(qfunc != null) {
					
					AIMSMapFunctionality aimsMapFunc = qfunc.getMapFunctionality();
					List<WebLayerInfo> aimsLayers = qfunc.getQueryLayers();
					String serviceName = aimsMapResource.getServiceName();
					
					for(Iterator<WebLayerInfo> i = aimsLayers.iterator(); i.hasNext();) {
						WebLayerInfo layer = i.next();
						String layerName = serviceName + "." + layer.getName();
						
						if(aimsMapFunc.getLayer(layer.getId() + "") instanceof FeatureLayer && !newLayerList.containsValue(layerName)) {
							newLayerList.put(resourceId + "!" + layer.getId(), layerName);
						}
					}
				}
			}
			
			return newLayerList;
		
		} catch(Exception e) {
			logger.warn("Unable to get aims service layer list", e);
		}
		
		return null;
	}
}