aimsbuffertask.java

实例实例实例实例实例实例实例实例实例实例实例实例实例实例实例实例

package com.esri.adf.web.aims.tasks;

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

import com.esri.adf.web.data.WebContext;
import com.esri.adf.web.data.geometry.WebGeometry;
import com.esri.adf.web.data.query.IdentifyCriteria;
import com.esri.adf.web.data.query.WebQuery;
import com.esri.adf.web.data.query.QueryResult;
import com.esri.adf.web.data.WebContextInitialize;
import com.esri.adf.web.data.WebContextObserver;
import com.esri.adf.web.data.WebLayerInfo;
import com.esri.adf.web.data.results.WebResults;
import com.esri.adf.web.data.results.WebResultsToc;
import com.esri.adf.web.data.tasks.TaskInfo;
import com.esri.adf.web.data.tasks.TaskInfoBean;
import com.esri.adf.web.faces.event.MapEvent;
import com.esri.adf.web.faces.event.TaskEvent;
import com.esri.adf.web.aims.data.AIMSMapFunctionality;
import com.esri.adf.web.aims.data.AIMSMapResource;
import com.esri.adf.web.aims.tasks.AIMSBufferResultRecord;

import com.esri.adf.web.tasks.SearchAttributesUtil;

import com.esri.aims.mtier.model.map.Map;
import com.esri.aims.mtier.model.map.Layers;
import com.esri.aims.mtier.model.map.layer.FeatureLayer;
import com.esri.aims.mtier.model.map.layer.query.Buffer;
import com.esri.aims.mtier.model.map.layer.query.Filter;
import com.esri.aims.mtier.model.map.layer.renderer.symbol.SimpleLineSymbol;
import com.esri.aims.mtier.model.map.layer.renderer.symbol.SimpleMarkerSymbol;
import com.esri.aims.mtier.model.map.layer.renderer.symbol.SimplePolygonSymbol;

public class AIMSBufferTask implements WebContextInitialize, WebContextObserver, TaskInfoBean
{
	private TaskInfo taskInfo = null;
	private String taskName = "ArcIMS Buffer Task";
	private WebContext context = null;
	
	private AIMSMapResource aimsResource = null;
	
	private WebResultsToc resultsToc = null;
	private WebResults results = null;

	private LinkedHashMap aimsResourceList = null;
	private LinkedHashMap layerList = null;
	private LinkedHashMap bufferLayerList = null;
	private LinkedHashMap targetLayerList = null;
	private LinkedHashMap bufferUnitList = null;
	
	private int aimsResourceId = 0;
	private int layerId = 0;
	private int bufferLayerId = 0;
	private int targetLayerId = 0;
	
	private String bufferUnit = "MILES";
	private int bufferUnitId = 0;
	private int bufferDistance = 5;
	private String whereClause = "NAME = 'STEVENS CREEK'";
	private QueryResult currentHighlighted = null;
	
	private AIMSBufferResultRecord currentRecords;
	private ArrayList resultRecords;

	private String actionName;
	
	public String getActionName() {
		return actionName;
	}

	public void setActionName(String actionName) {
		this.actionName = actionName;
	}

	public AIMSBufferTask()
	{
		this.taskInfo = new AIMSBufferTaskInfo();
	}
	
	public void destroy() {}

	public void init(WebContext context) 
	{
		setContext(context);
	}

	public void update(WebContext context, Object arg) 
	{
		
	}
	
	public String processAction() 
	{
	    if(this.resultsToc.getSelectedResult() !=  null)
	    {
	        this.resultsToc.getSelectedResult().processAction(this.actionName);
	    }
	    return null;
	}
	
	public void doSelectAimsResource(TaskEvent event)
	{
		//System.out.println(this.aimsResourceId);
		//System.out.println(getResourceById(this.aimsResourceId).getServiceName());
		this.setAimsResource(getResourceById(this.aimsResourceId));
		this.bufferLayerList = AIMSBufferTaskUtil.getLayerList(this.aimsResource);
	    this.targetLayerList = AIMSBufferTaskUtil.getLayerList(this.aimsResource);
	}
	
	public void searchByClick(MapEvent event) 
	{
	    try
	    {
			WebQuery wQuery = (WebQuery)event.getWebContext().getAttribute("query");
		    WebGeometry geom = event.getWebGeometry().toMapGeometry(this.context.getWebMap());
		    IdentifyCriteria ic = new IdentifyCriteria(geom);  
	    	
		    List searchResults = wQuery.query(ic, AIMSBufferTaskUtil.getWebLayerInfoList(wQuery.getQueryLayers(),layerId));
		    System.out.println(searchResults.size());
		    this.context.getWebQuery().clearGraphics();
		    for(int i=0; i<searchResults.size(); i++)
		    {
		    	QueryResult result = (QueryResult)searchResults.get(i);	    	
		    	result.highlight();
		    	this.currentHighlighted = result;
		    }
		    this.context.refresh();
	    }
	    catch(Exception e)
	    {
	    	System.out.println(e.getMessage());
	    }	    
	    //event.getWebContext().getWebResults().addResultsWithActionMap("Search By Extent :" + geom , results, "getName", "getDetails", null);
	}
	
	public void clearResults(TaskEvent event)
	{
		this.context.getWebResults().clearAll();
		this.context.refresh();
	}
	
	public void clearMap(TaskEvent event)
	{
		if(this.aimsResource != null)
		{
			//System.out.println("arcims map resource is empty...");
			
			Map aims_map = null;
	    	AIMSMapFunctionality aims_map_func = null;
			
			aims_map_func = (AIMSMapFunctionality)(this.aimsResource.getFunctionality("map"));
			aims_map = aims_map_func.getMap();			
			
			Layers aims_layers = aims_map.getLayers();
			
			FeatureLayer fromLayer = (FeatureLayer)aims_layers.item(this.bufferLayerId);
			FeatureLayer targetLayer = (FeatureLayer)aims_layers.item(this.targetLayerId);
			
			fromLayer.setFilterObject(null);
			targetLayer.getRecordset().clearRecordset();
			targetLayer.getRecordset().clearGeometry();
			targetLayer.getRecordset().setGeometry(null);
			targetLayer.setFilterObject(null);
			
			aims_map.createBufferImage(false, false);
			aims_map.clearBuffer();
			aims_map.refresh();
						
			this.context.getWebQuery().clearGraphics();
			this.context.refresh();			
		}
	}

	public void doBuffer(TaskEvent event)
	{
		try
		{
			/*
			System.out.println(this.bufferLayerId);
			System.out.println(this.targetLayerId);
			System.out.println(this.bufferDistance);
			System.out.println(AIMSBufferTaskUtil.AIMS_BUFFER_UNIT[this.bufferUnitId]);
			System.out.println(this.whereClause);
			*/
			
			//pocess the buffer operation
			Filter filter = new Filter();
	    	Filter targetFilter = new Filter();
	    	
	    	FeatureLayer fromLayer = null;
	    	FeatureLayer targetLayer = null;
	    	FeatureLayer resultLayer = null;
	    	
	    	SimpleMarkerSymbol simpleMarker = null;
	    	SimpleLineSymbol simpleLine = null;
	    	SimplePolygonSymbol simplePolygon =  null;
	    	SimplePolygonSymbol simplePolygonBuffer =  new SimplePolygonSymbol();
	    	
	    	Map aims_map = null;
	    	Layers aims_layers = null;
	    	AIMSMapFunctionality aims_map_func = null;
	    	
	    	Buffer buffer = new Buffer();
	        
	    	if(this.aimsResource == null)
			{
				System.out.println("arcims map resource is empty...");
	    		return;
			}
	    	
	    	aims_map_func = (AIMSMapFunctionality)(this.aimsResource.getFunctionality("map"));
			aims_map = aims_map_func.getMap();
	    	aims_layers = aims_map.getLayers();
	    	
	    	List tempList = AIMSBufferTaskUtil.getWebLayerInfoList(context.getWebQuery().getQueryLayers(),layerId);
	    	//System.out.println(((WebLayerInfo)tempList.get(0)).getName());
	    	
	    	this.bufferLayerId = this.getLayerIdxByName(this.aimsResource, ((WebLayerInfo)tempList.get(0)).getName());
	    	
	    	fromLayer = (FeatureLayer)aims_layers.item(this.bufferLayerId);
	        targetLayer = (FeatureLayer)aims_layers.item(this.targetLayerId);
	
	        buffer.setPerformBuffer(true);
	        buffer.setBufferUnits(AIMSBufferTaskUtil.AIMS_BUFFER_UNIT[this.bufferUnitId]);
	        buffer.setBufferDistance(this.bufferDistance);    
	        buffer.setBufferRegionSymbol(simplePolygonBuffer);
	        
	        simplePolygonBuffer.setFillColor("0,255, 0");
	        simplePolygonBuffer.setFillType(SimplePolygonSymbol.SOLID);
	        simplePolygonBuffer.setFillTransparency(0.2);
	        
	        String targetLayerType = targetLayer.getFeatureClass();
	        
	        if(targetLayerType.equalsIgnoreCase("point") == true)
			{
				simpleMarker = new SimpleMarkerSymbol();
				simpleMarker.setColor("0,0,255");
				simpleMarker.setMarkerType("STAR");
				simpleMarker.setTransparency(1);
				simpleMarker.setOutline("255,255,255");
				simpleMarker.setWidth(16);
				buffer.setBufferSelectionSymbol(simpleMarker); 
			}
			else if(targetLayerType.equalsIgnoreCase("line") == true)
			{
				simpleLine = new SimpleLineSymbol();
		        simpleLine.setColor("0,255,0");
		        simpleLine.setLineType(SimpleLineSymbol.DASH_DOT);
		        simpleLine.setTransparency(1.0);
		        simpleLine.setAntialiasing(true);
		        simpleLine.setCapType("round");
		        simpleLine.setOverlap(true);
		        simpleLine.setWidth(2);
		        buffer.setBufferSelectionSymbol(simpleLine); 
			}
			else if(targetLayerType.equalsIgnoreCase("polygon") == true)
			{
				simplePolygon = new SimplePolygonSymbol();
				simplePolygon.setBoundary(true);
				simplePolygon.setBoundaryColor("150,150,150");
				simplePolygon.setBoundaryWidth(1);
				simplePolygon.setFillColor("255,0,0");
				simplePolygon.setFillTransparency(0.5);
				buffer.setBufferSelectionSymbol(simplePolygon);
			}
			else {}
	
	        buffer.setBufferTargetLayer(targetLayer);
	
	        filter.setGlobalEnvelope(true);
	
	        //String whereExp = this.whereClause;	     	        
	        String whereExp = "";
	        java.util.Map details = this.currentHighlighted.getDetails();
	        for(Iterator iter=details.keySet().iterator(); iter.hasNext();)
			{
				String key = (String)iter.next();
				if(key.equalsIgnoreCase("#ID#") == true)
				{
					whereExp = key + " = " + (String)details.get(key);
					System.out.println(whereExp);					
				}
			}	        
	        	       	     	        	       
	        filter.setWhereExpression(whereExp);
	        filter.setBufferObject(buffer);
	        fromLayer.setFilterObject(filter);
	        
	        targetLayer.getRecordset().clearRecordset();
	        targetLayer.setFilterObject(targetFilter);
	        
	        aims_map.clearBuffer();
	        aims_map.createBufferImage(true, true);       
	        aims_map.refresh();
	        
	        //get the buffer result 
	        //get the buffer results from BufferLayer's recordset
	              
	        int resultLayerIdx = this.getLayerIdxByName(this.aimsResource, "BufferLayer");
	        resultLayer = (FeatureLayer)aims_layers.item(resultLayerIdx);
	        
	       
	        this.resultRecords =  new ArrayList();
	        this.resultRecords.clear();