querybuildertask.java

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

        taskInfo.getTaskDescriptor().setShouldRender(Boolean.TRUE);
        m_exportingSavedQuery = false;

        if (m_persistenceService == null) {
            throw new IllegalStateException("persistence service not set");
        }

        fc = FacesContext.getCurrentInstance();
        strData = new String((byte[]) fc.getExternalContext().getSessionMap().get(getUploadId()));

        if ((strData == null) || (strData.length() <= 0)) {
            _logger.warn("Invalid query xml - cannot import saved QueryBuilder query");
            return;
        }

        _logger.debug("Importing query using uploaded data: " + strData);

        try {
            obj = m_persistenceService.retrieveFromXml(strData);
            loadQuery(event.getWebContext(), obj);
        } catch (PersonalizationException ex) {
            _logger.warn("PersonalizationException occurred loading QueryBuilder query from xml", ex);

            String message = "Unable to import selected query file.";

            if (ex.getCode().equals(PersonalizationException.Code.SERIALIZATION_ERROR)) {
                message = "Invalid query file - unable to import selected query.";
            }

            this.renderMessage(message);
        } catch (IllegalArgumentException ex) {
            _logger.warn("Illegal argument exception occurred trying to import query - unable to import selected query");
            _logger.debug("Illegal argument exception occurred trying to import query - unable to import selected query", ex);

            renderExceptionMessage(ex);
        }
    }

    public void deleteQuery(TaskEvent event) {
        try {
            m_exportingSavedQuery = false;

            _logger.info("Deleting Query");

            UUID id = UUID.fromString(getSelectedQuery());
            IQuery query = personalizationCtx.getData().getQuery(id);
            query.remove();

            //reset the list
            m_queries.clear();

            // refresh the list in load task		
            List<IQuery> list = personalizationCtx.getData().getQueries();
            Iterator iter = list.iterator();

            while (iter.hasNext()) {
                IQuery newquery = (IQuery) iter.next();

                if (newquery.getType().equals(IQuery.Type.FEATURE)) {
                    m_queries.put(newquery.getId().toString(),
                        newquery.getName());
                }
            }
        } catch (Exception ex) {
            renderExceptionMessage(ex);
            _logger.error("Unable to delete query", ex);
        }
    }

    public void saveQueryDescription(TaskEvent event) {
        m_exportingSavedQuery = false;
    }

    public void setSaveQueryDescription(String desc) {
        m_saveQyeryDescription = desc;
    }

    public String getSaveQueryDescription() {
        return m_saveQyeryDescription;
    }

    public String getSaveQueryName() {
        return m_saveQueryName;
    }

    public void setSaveQueryName(String name) {
        m_saveQueryName = name;
    }

    public Integer getSaveQueryMethod() {
        return m_saveQueryMethod;
    }

    public void setSaveQueryMethod(Integer method) {
        m_saveQueryMethod = method;
    }

    public Map<Integer, String> getSaveQueryMethods() {
        return m_saveQueryMethods;
    }

    public Map<Integer, String> getLoadQueryMethods() {
        return m_loadQueryMethods;
    }

    public Integer getLoadQueryMethod() {
        return m_loadQueryMethod;
    }

    public void setLoadQueryMethod(Integer method) {
        m_loadQueryMethod = method;
    }

    public String getSelectedQuery() {
        return m_selectedQuery;
    }

    public void setSelectedQuery(String queryId) {
        m_selectedQuery = queryId;
    }

    public Map<String, String> getQueries() {
    	if (shouldRefresh()) {
    		refresh();
    	}
        return m_queries;
    }

    public String getUploadFilename() {
        return m_uploadFilename;
    }

    public void setUploadFilename(String filename) {
        m_uploadFilename = filename;
    }

    public String getUploadId() {
        return m_uploadId;
    }

    public void setUploadId(String id) {
        m_uploadId = id;
    }

    public boolean getShowQuerySelection() {
        return (m_queries.size() > 0);
    }

    /**
     * WebADF doesn't support line geometry query.
     */
    public void queryLine(MapEvent event) {
        _logger.info("Performing query by line selection");
        requestTaskRender();
      
        event.getWebContext().getWebQuery().clearGraphics();
        event.getWebContext().getWebResults().clearAll();
		
        try {
            WebPolyline webLine = (WebPolyline) event.getWebGeometry().toMapGeometry(event.getWebContext().getWebMap());
            WebGeometry webGeometry = (WebGeometry) webLine;
            filterGraphics = new GraphicElement();
            filterGraphics.setGeometry(webGeometry);
            queryLayer();
            
        } catch (Exception ex) {
        	renderResourceMessage("querybuildertask.msg.error.couldNotPerformQuery", ex);
            _logger.error("Unable to query specified by line location", ex);
        }
    }

    /**
     * WebADF doesn't support line geometry query.
     */
    public void queryPolyline(MapEvent event) {
        _logger.info("Performing query by polyline selection");
        requestTaskRender();
        
        event.getWebContext().getWebQuery().clearGraphics();
        event.getWebContext().getWebResults().clearAll();
        
        try {
            WebGeometry webGeo = event.getWebGeometry();
            WebMap webMap = event.getWebContext().getWebMap();
            WebPolyline webPolyline = (WebPolyline) webGeo.toMapGeometry(webMap);
            WebGeometry webGeometry = (WebGeometry) webPolyline;
            filterGraphics = new GraphicElement();
            filterGraphics.setGeometry(webGeometry);
            queryLayer();
            
        } catch (Exception ex) {
        	renderResourceMessage("querybuildertask.msg.error.couldNotPerformQuery", ex);
            _logger.error("Unable to query specified by polyline location", ex);
        }
    }

    /**
     * WebADF doesn't support circle geometry query.
     */
    @SuppressWarnings("deprecation")
    public void queryCircle(MapEvent event) {
        _logger.info("Performing query by circle selection");
        requestTaskRender();

        event.getWebContext().getWebQuery().clearGraphics();
        event.getWebContext().getWebResults().clearAll();
		
        try {
            WebGeometry webGeo = event.getWebGeometry();
            WebMap webMap = event.getWebContext().getWebMap();
            WebCircle webCircle = (WebCircle) webGeo.toMapGeometry(webMap);
            WebGeometry webGeometry = (WebGeometry) webCircle;
            filterGraphics = new GraphicElement();
            filterGraphics.setGeometry(webGeometry);
            queryLayer();
            
        } catch (Exception ex) {
        	renderResourceMessage("querybuildertask.msg.error.couldNotPerformQuery", ex);
            _logger.error("Unable to query specified by circle location", ex);
        }
    }

    @SuppressWarnings("deprecation")
    public void queryOval(MapEvent event) {
        _logger.info("Performing query by oval selection");
        super.requestTaskRender();
        
        event.getWebContext().getWebQuery().clearGraphics();
        event.getWebContext().getWebResults().clearAll();
        
        try {
            WebGeometry webGeo = event.getWebGeometry();
            WebMap webMap = event.getWebContext().getWebMap();
            WebOval webOval = (WebOval) webGeo.toMapGeometry(webMap);
            WebGeometry webGeometry = (WebGeometry) webOval;
            filterGraphics = new GraphicElement();
            filterGraphics.setGeometry(webGeometry);
            queryLayer();
        
        } catch (Exception ex) {
        	renderResourceMessage("querybuildertask.msg.error.couldNotPerformQuery", ex);
            _logger.error("Unable to query specified by oval location", ex);
        }
    }

    public void drawPoly(WebPolygon wPoly) {
        WebGeometry webGeometry = (WebGeometry) wPoly;
        WebSymbol symbol = getSymbol();

        filterGraphics = new GraphicElement();
        filterGraphics.setGeometry(webGeometry);

        // enable the Query Selection Button
        enableQuerySelectionBtn(true);

        // set the currently selected tool
        selectedToolDesc = SelectedToolDesc.RECT;

        // delete any previous shapes added to map
        mgResource.deleteAllGraphicFeatures();

        mgResource.addGraphicFeature(webGeometry, symbol);
        _logger.debug("Context refresh requested");

        _context.refresh();
    }

    public void drawPoly(PolygonN poly) {
        try {
            PersonalizationGeometryConverter converter = new PersonalizationGeometryConverter();
            drawPoly((WebPolygon) converter.toWebGeometry(poly));
        
        } catch (Exception ex) {
            _logger.error(ex.toString());
        }
    }

    public void drawPoly(MapEvent event) {
        try {
            drawPoly((WebPolygon) event.getWebGeometry().toMapGeometry(event.getWebContext().getWebMap()));   
        } catch (Exception ex) {
            renderExceptionMessage(ex);
            _logger.error("Unable to Draw Polygon graphic", ex);
        }
    }

    public void drawRect(MapEvent event) {
        try {
            drawPoly(GeometryConverter.toWebPolygon((WebExtent) event.getWebGeometry().toMapGeometry(event.getWebContext().getWebMap())));
        } catch (Exception ex) {
            renderExceptionMessage(ex);
            _logger.error("Unable to Draw Polygon graphic", ex);
        }
    }

    public void drawPoint(WebGeometry webGeom) {
        WebSymbol pSymbol = createSymbol();

        filterGraphics = new GraphicElement();
        filterGraphics.setGeometry(webGeom);

        // enable the Query Selection Button
        enableQuerySelectionBtn(true);

        // set the currently selected tool
        selectedToolDesc = SelectedToolDesc.POINT;

        // delete any previous shapes added to map
        mgResource.deleteAllGraphicFeatures();

        mgResource.addGraphicFeature(webGeom, pSymbol);

        _context.refresh();
    }

    public void drawPoint(PointN point) {
        try {
            PersonalizationGeometryConverter converter = new PersonalizationGeometryConverter();
            drawPoint((WebPoint) converter.toWebGeometry(point));
        } catch (Exception ex) {
            _logger.error(ex.toString());
        }
    }

    public void drawPoint(MapEvent event) {
        try {
            requestTaskRender();
            drawPoint(event.getWebGeometry().toMapGeometry(event.getWebContext().getWebMap()));
        } catch (Exception ex) {
            renderExceptionMessage(ex);
            _logger.error("Unable to Draw Point graphic", ex);
        }
    }

    // Had to add a separate action method name for each TaskToolDescriptor, otherwise
    // the tools were showing up several times each
    public void rectEnableSelectButton(MapEvent event) {
        // enable the Query Selection Button
        enableQuerySelectionBtn(true);

        // set the currently selected tool
        selectedToolDesc = SelectedToolDesc.RECT;

        // delete any previous shapes added to map
        mgResource.deleteAllGraphicFeatures();

        // draw the rectangle on the map
        drawRect(event);
    }

    public void pointEnableSelectButton(MapEvent event) {
        // enable the Query Selection Button
        enableQuerySelectionBtn(true);

        // set the currently selected tool
        selectedToolDesc = SelectedToolDesc.POINT;

        // delete any previous shapes added to map
        mgResource.deleteAllGraphicFeatures();

        // draw the point on the map
        drawPoint(event);
    }

    public void polyEnableSelectButton(MapEvent event) {
        // enable the Query Selection Button
        enableQuerySelectionBtn(true);

        // set the currently selected tool
        selectedToolDesc = SelectedToolDesc.POLY;

        // delete any previous shapes added to map
        mgResource.deleteAllGraphicFeatures();

        // draw the rectangle on the map
        drawPoly(event);
    }

    public void ovalEnableSelectButton(MapEvent event) {
        // enable the Query Selection Button
        enableQuerySelectionBtn(true);

        // set the currently selected tool
        selectedToolDesc = SelectedToolDesc.OVAL;
    }

    // This will enable or disable the Query Selection button
    private void enableQuerySelectionBtn(boolean enable) {
        TaskActionDescriptor[] td = (TaskActionDescriptor[]) taskInfo.getActionDescriptors();

        if (enable) {
            for (TaskActionDescriptor tad : td) {
                if (tad