Implement the REST SOE's interfaces

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class SimpleRESTSOE implements IServerObjectExtension, IRESTRequestHandler{
    private static final long serialVersionUID = 1L;
    private IServerObjectHelper soHelper;
    private ILog serverLog;
    private IMapLayerInfos layerInfos;

    public SimpleRESTSOE()throws Exception{
        super();
    }

    /**
     * init() is called once, when the instance of the SOE is created.
     */
    public void init(IServerObjectHelper soh)throws IOException, AutomationException{
        this.soHelper = soh;
        this.serverLog = ServerUtilities.getServerLogger();

        IMapServer ms = (IMapServer)this.soHelper.getServerObject();
        IMapServerInfo mapServerInfo = ms.getServerInfo(ms.getDefaultMapName());
        this.layerInfos = mapServerInfo.getMapLayerInfos();

        serverLog.addMessage(3, 200, "Initialized " + this.getClass().getName() +
            " SOE.");
    }

    /**
     * shutdown() is called once when map service is shutting down
     */
    public void shutdown()throws IOException, AutomationException{
        serverLog.addMessage(3, 200, "Shutting down " + this.getClass().getName() +
            " SOE.");
        this.soHelper = null;
        this.serverLog = null;
    }
	...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public String getSchema()throws IOException,AutomationException{
	try{
					JSONObject javaSimpleRESTSOE = ServerUtilities.createResource("javaSimpleRESTSOE",
			"javaSimpleRESTSOE description",false,false);

		JSONArray _subResourcesArray = new JSONArray();
		_subResourcesArray.put(ServerUtilities.createResource("layers",
				"layers in associated map service", false, false));
		_subResourcesArray.put(ServerUtilities.createResource("serviceproperties",
				"service properties associated map service", false, false));
		javaSimpleRESTSOE.put("resources", _subResourcesArray);

		JSONArray _OpArray = new JSONArray();
		_OpArray.put(ServerUtilities.createOperation("getLayerCountByType",
				"type", "json", false));
		javaSimpleRESTSOE.put("operations", _OpArray);

		return javaSimpleRESTSOE.toString();
	}catch(JSONException e){
		e.printStackTrace();
	}
	return null;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
@Override
public byte[] handleRESTRequest(String capabilities, String resourceName,
								String operationName, String operationInput, String outputFormat,
								String requestProperties, String[] responseProperties)
		throws IOException, AutomationException {
	try {

		Map<String, String> responsePropertiesMap = new HashMap<String, String>();
		byte[] response = null;
		if (operationName.length() == 0) {
			// invoke the REST resource
			response = getResource(resourceName, responsePropertiesMap);
		} else
		{
			// invoke the REST operation on specified resource
			response = invokeRESTOperation(capabilities, resourceName,
					operationName, operationInput, outputFormat,
					requestProperties, responsePropertiesMap);
		}

		//collect response properties that may have changed in subresources or operations
		JSONObject responsePropertiesJSON = new JSONObject(responsePropertiesMap);
		responseProperties[0] = responsePropertiesJSON.toString();

		//return a response
		return response;
	} catch (Exception e) {
		this.serverLog.addMessage(1, 500, e.getMessage());
		return ServerUtilities.sendError(500,
				"Exception occurred: " + e.getMessage(),
				new String[] { "No details specified." }).getBytes("utf-8");
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public JSONObject getLayersInfoAsJSON() throws Exception {
	JSONObject json = new JSONObject();

	int count = this.layerInfos.getCount();
	json.put("layerCount", count);
	JSONArray layerArray = new JSONArray();
	for (int i = 0; i < count; i++) {
		IMapLayerInfo layerInfo = layerInfos.getElement(i);
		JSONObject layerJSON = new JSONObject();
		layerJSON.put("name", layerInfo.getName());
		String layerType = layerInfo.getType();
		layerJSON.put("type", layerType);
		int id = layerInfo.getID();
		layerJSON.put("id", id);
		layerJSON.put("description", layerInfo.getDescription());
		if (layerInfo.isFeatureLayer()) {
			IMapServerDataAccess mapServerDataAccess = (IMapServerDataAccess) this.soHelper.getServerObject();
			IMapServer ms = (IMapServer)mapServerDataAccess;
			FeatureClass fc = new FeatureClass(mapServerDataAccess.getDataSource(ms.getDefaultMapName(), id));
			layerJSON.put("featureCount", fc.featureCount(null));
		}

		layerArray.put(i, layerJSON);
	}
	json.put("layersInfo", layerArray);
	return json;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
private byte[] getLayerCountByType(JSONObject operationInput, java.util.Map<String, String> responsePropertiesMap)
		throws Exception {
	String type = operationInput.getString("type");

	JSONObject json = new JSONObject();

	int count = 0;
	if (type != null && !type.isEmpty()) {
		String aoType = "";
		if (type.equalsIgnoreCase("all")) {
			count = layerInfos.getCount();
		} else if (type.equalsIgnoreCase("feature")) {
			aoType = "Feature Layer";
		} else if (type.equalsIgnoreCase("raster")) {
			aoType = "Raster Layer";
		} else if (type.equalsIgnoreCase("dataset")) {
			aoType = "Network Dataset Layer";
		}

		for (int i = 0; i < layerInfos.getCount(); i++) {
			if (layerInfos.getElement(i).getType().equalsIgnoreCase(aoType)) {
				count++;
			}
		}

		json.put("count", count);

		responsePropertiesMap.put("Content-Type", "application/json");

		return json.toString().getBytes();
	} else {
		throw new Exception(
				"Invalid layer type provided. Available types are: \"all\", \"feature\", \"raster\", \"dataset\".");
	}
}