selectbylocationtask.java

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

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

import com.esri.adf.web.ags.data.AGSMapResource;
import com.esri.adf.web.aims.data.AIMSMapResource;
import com.esri.adf.web.aws.data.AWSResource;
import com.esri.adf.web.data.GISResource;
import com.esri.adf.web.data.WebContext;
import com.esri.adf.web.data.WebLayerInfo;
import com.esri.adf.web.data.geometry.WebCircle;
import com.esri.adf.web.data.geometry.WebGeometry;
import com.esri.adf.web.data.geometry.WebOval;
import com.esri.adf.web.data.query.IdentifyCriteria;
import com.esri.adf.web.data.query.QueryFunctionality;
import com.esri.adf.web.data.query.QueryResult;
import com.esri.adf.web.data.query.WebQuery;
import com.esri.adf.web.data.results.WebResults;
import com.esri.adf.web.data.tasks.TaskActionDescriptor;
import com.esri.adf.web.data.tasks.TaskInfo;
import com.esri.adf.web.data.tasks.TaskUtils;
import com.esri.adf.web.faces.event.MapEvent;
import com.esri.adf.web.faces.event.TaskEvent;

import com.esri.solutions.jitk.common.geometry.GeometryConverter;
import com.esri.solutions.jitk.common.resources.TextResources;
import com.esri.solutions.jitk.web.tasks.ResultProducingTask;
import com.esri.solutions.jitk.web.wfs.data.WFSMapResource;

import org.apache.log4j.Logger;

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


@SuppressWarnings("deprecation")
public class SelectByLocationTask extends ResultProducingTask {
    private static final long serialVersionUID = 811861378279555191L;
    private static final Logger _logger = Logger.getLogger(SelectByLocationTask.class);
    private String _qualifiedLayerName;
    private Map<String, String> _selectableLayerNamesAndAliasNames; //<displayName, layername>	
    private SelectByLocationTaskInfo _taskInfo;
    private boolean _hideUpdateButton;
    private String _layerListLabel; //= "from:"; // text1
    private String _selectToolsLabel; //= "Specify area of interest:"; // text2
    private String _selectToolsHelpText; //= "<i>(select a tool and specify area of interest on map)</i>"; // text3
    private String footerNote = null;

    public SelectByLocationTask() {
        super();
        setTaskInfo(new SelectByLocationTaskInfo(this.getClass()));

        this._selectToolsLabel = TextResources.getResourceString(
                "selectiontask.ui.label.specifyAreaOfInterest");
        this._layerListLabel = TextResources.getResourceString(
                "selectiontask.ui.label.from");
        this._selectToolsHelpText = TextResources.getResourceString(
                "selectiontask.ui.label.selectATool");
    }

    public void clearSelections(TaskEvent event) {
        try {
            _logger.info("Clearing selections");
            requestTaskRender();

            event.getWebContext().getWebQuery().clearGraphics();
        } catch (Exception ex) {
            renderExceptionMessage(ex);
            _logger.error("Could not clear selections", ex);
        }
    }

    public void updateSelectableLayers(TaskEvent event) {
        try {
            _logger.info("Updating layer list");
            requestTaskRender();

            _selectableLayerNamesAndAliasNames = getSelectableLayers();
        } catch (Exception ex) {
            renderExceptionMessage(ex);
            _logger.error("Could not update layer selection list", ex);
        }
    }

    @SuppressWarnings({"deprecation", "unchecked"})
    private void selectByGeometry(MapEvent event) {
        _logger.info("Query by location service layer: " + _qualifiedLayerName);
        requestTaskRender();
        
        event.getWebContext().getWebQuery().clearGraphics();
        event.getWebContext().getWebResults().clearAll();
        
        String gisResKey;
        String layerName = null;
        WebResults wResults = null;

        try {
            try {
                int dotIndex = _qualifiedLayerName.indexOf('.');
                gisResKey = _qualifiedLayerName.substring(0, dotIndex);
                layerName = _qualifiedLayerName.substring(dotIndex + 1,
                        _qualifiedLayerName.length());
            } catch (Exception e) {
                throw new Exception("Cannot continue, Possibly invalid layer selected/specified[" + _qualifiedLayerName + "]", e);
            }

            WebContext webContext = event.getWebContext();
            wResults = webContext.getWebResults();

            WebQuery webQuery = webContext.getWebQuery();

            WebGeometry webGeometry = event.getWebGeometry().toMapGeometry(event.getWebContext().getWebMap());
            _logger.debug("Geometry received: " + webGeometry.getGeometryType() + " " + webGeometry);

            if (webGeometry instanceof WebCircle) {
                webGeometry = GeometryConverter.toWebPolygon((WebCircle) webGeometry);
            } else if (webGeometry instanceof WebOval) {
                throw new Exception("WebADF is unable to query against oval type of geometries.");
            }

            GISResource gisRes = (GISResource) webContext.getResources().get(gisResKey);
            if (gisRes == null) {
                throw new Exception("GISResource[key:" + gisResKey + "]=null from WebContext.");
            }

            List<QueryResult> currentSelection = webQuery.query(new IdentifyCriteria(webGeometry), findWebLayerInfo(webQuery, layerName, gisRes));
            //check the query results
            if((currentSelection == null) || (currentSelection.size() == 0)) {
                wResults.addResultsWithActionMap("Nothing found on " + layerName, null, null, null, null);
            } else {
                wResults.addResultsWithActionMap("Selection Results on " + layerName, currentSelection, "getName", "getDetails", super.getActions());
            }

            // highlight the results
            this.highlightResults(currentSelection);

            webContext.refresh();
            
        } catch (Exception e) {
            _logger.error("Unable to perform select by Geometry: " + e.getMessage(), e);
            renderExceptionMessage(e);

            if(wResults != null) {
                wResults.addResultsWithActionMap("Unable to select on layer:" + _qualifiedLayerName, null, null, null, null);
            }
        }
    }

    public List<WebLayerInfo> findWebLayerInfo(final WebQuery webQuery, final String layerName, final GISResource gisRes) {
        List<WebLayerInfo> list = new ArrayList<WebLayerInfo>();

        if(webQuery.getQueryLayers() != null) {
            for(Object o : webQuery.getQueryLayers()) {
                WebLayerInfo info = (WebLayerInfo) o;

                //TODO revise this condition, equals on GISResource may not work
                if (info.getName().equalsIgnoreCase(layerName) && info.getResource().equals(gisRes)) {
                    list.add(info);
                    break;
                }
            }
        }

        if (list.size() <= 0) {
            _logger.warn("Unable to find any WebLayerInfo for layerName[" + layerName + "]");
        }

        return list;
    }

    @SuppressWarnings("unchecked")
    public List<String> getLayerNames(final QueryFunctionality queryFunc) {
        List<String> layerNames = new ArrayList<String>();
        List<WebLayerInfo> webLayers = queryFunc.getQueryLayers();

        for (WebLayerInfo webLayerInfo : webLayers) {
            layerNames.add(webLayerInfo.getName());
        }

        return layerNames;
    }

    @SuppressWarnings("unchecked")
    protected Map<String, String> getSelectableLayers() {
        Map<String, String> selectableLayers = new LinkedHashMap<String, String>();

        try {
            Map<String, GISResource> resources = getContext().getResources();

            for (String gisResKey : resources.keySet()) {
                
            	try {
                    GISResource gisRes = resources.get(gisResKey);

                    if (gisRes == null) {
                        _logger.error("Found NULL value for a GISResource[key=" + gisResKey + "]");
                        continue;
                    }

                    if (gisRes instanceof AGSMapResource ||
                            gisRes instanceof AIMSMapResource ||
                            gisRes instanceof AWSResource ||
                            gisRes instanceof WFSMapResource)
                    {
                        
                    	try {
                            QueryFunctionality queryFunc = (QueryFunctionality) gisRes.getFunctionality(QueryFunctionality.FUNCTIONALITY_NAME);
                            if (queryFunc == null) {
                                _logger.warn("Ignoring GISResource [key:" + gisResKey + ", alias:" + gisRes.getAlias() + "], " + "QueryFunctionality has not been enabled");
                                continue;
                            }

                            List<String> list = getLayerNames(queryFunc);
                            for (String layerName : list) {
                                selectableLayers.put(gisResKey + "." + layerName, gisRes.getAlias() + "." + layerName);
                            }
                        } catch (Exception e) {
                            _logger.warn("Unable to get layers from AGSMapResource[" + gisResKey + "]", e);
                        }
                    } else { //ignore other resource types
                    }
                
                } catch (Exception e) {
                    _logger.warn("(Ignorable) Unable to get layers for GISResource[key=" + gisResKey + "]", e);
                }
            }
        } catch (Exception e) {
            _logger.error("Unable to populate layer names drop down list, error: " + e.getMessage(), e);
        }

        return selectableLayers;
    }

    public Map<String, String> getSelectableLayerNamesAndAliasNames() {
        if (_selectableLayerNamesAndAliasNames == null) {
            _selectableLayerNamesAndAliasNames = getSelectableLayers();
        }

        return _selectableLayerNamesAndAliasNames;
    }

    public void selectByPoint(final MapEvent event) throws Exception {
        requestTaskRender();
        selectByGeometry(event);
    }

    public void selectByRectangle(MapEvent event) throws Exception {
        requestTaskRender();
        selectByGeometry(event);
    }

    public void selectByPolygon(MapEvent event) throws Exception {
        requestTaskRender();
        selectByGeometry(event);
    }

    public void selectByCircle(MapEvent event) throws Exception {
        requestTaskRender();
        selectByGeometry(event);
    }

    public void selectByLine(MapEvent event) throws Exception {
        requestTaskRender();
        selectByGeometry(event);
    }

    public void selectByPolyline(MapEvent event) throws Exception {
        requestTaskRender();
        selectByGeometry(event);
    }

    public void selectByOval(MapEvent event) throws Exception {
        requestTaskRender();
        selectByGeometry(event);
    }

    public void setHideUpdateButton(boolean hideUpdateButton) {
        this._hideUpdateButton = hideUpdateButton;

        String name = "updateSelectableLayers";

        if (_taskInfo != null) {
            _taskInfo.getActionDescriptors();

            TaskActionDescriptor taskAction = (TaskActionDescriptor) TaskUtils.getActionDescriptor(name, _taskInfo);

            if (taskAction == null) {
                _logger.error("Unable to set visibility for update/refresh button, ActionDescriptor not found with name=" + name);
            } else {
                taskAction.setHidden(hideUpdateButton);
            }
        }
    }

    public void setSelectableLayerNamesAndAliasNames(
        Map<String, String> selectableLayerNamesAndAliasNames) {
        this._selectableLayerNamesAndAliasNames = selectableLayerNamesAndAliasNames;
    }

    public TaskInfo getTaskInfo() {
        if (this.getContext() == null) {
            _taskInfo.getTaskDescriptor().setDisabled(true);
            _logger.warn("WebContext not set, disabling");
        }

        return this._taskInfo;
    }

    public void setTaskInfo(TaskInfo taskInfo) {
        this._taskInfo = (SelectByLocationTaskInfo) taskInfo;
        super.setTaskInfo(this._taskInfo);
    }

    public String getAliasOfSelectedLayer() {
        return _qualifiedLayerName;
    }

    public void setAliasOfSelectedLayer(String aliasOfSelectedLayer) {
        this._qualifiedLayerName = aliasOfSelectedLayer;
    }

    public boolean isHideUpdateButton() {
        return _hideUpdateButton;
    }

    public String getSelectToolsLabel() {
        return _selectToolsLabel;
    }

    public String getLayerListLabel() {
        return _layerListLabel;
    }

    public String getSelectToolsHelpText() {
        return _selectToolsHelpText;
    }

    /**
     * Get footer note
     */
    public String getFooterNote() {
        return this.footerNote;
    }

    /**
     * Set footer note
     */
    public void setFooterNote(String footerNote) {
        this.footerNote = footerNote;
    }
}