@PUT
@Path("/edit")
@Consumes(MediaType.APPLICATION_JSON)
public void editNote(String inputData) {
JSONObject inputJSON = new JSONObject(inputData);
if ((inputJSON.has("sessionID"))
&& UsersController.checkLogin(inputJSON.getString("sessionID"))) {
if (inputJSON.has("noteID")) {
int id = Integer.parseInt(inputJSON.getString("noteID"));
editNote(inputData, id);
}
// w przeciwnym wypadku nic nie robi
}
}
@PUT
@Path("/edit/{id}")
@Consumes(MediaType.APPLICATION_JSON)
public void editNote(String inputData, @PathParam("id") int id) {
JSONObject inputJSON = new JSONObject(inputData);
if ((inputJSON.has("sessionID"))
&& UsersController.checkLogin(inputJSON.getString("sessionID"))) {
Note newNote = resolveNoteData(inputJSON);
if (inputJSON.has("noteID")) inputJSON.remove("noteID"); // na wszelki wypadek - ID podano
hibernate.controllers.NotesController notesController =
new hibernate.controllers.NotesController();
if (newNote != null) notesController.updateNote(newNote, id);
}
}
@POST
@Path("/create")
@Consumes(MediaType.APPLICATION_JSON)
public void createNote(String inputData) {
JSONObject inputJSON = new JSONObject(inputData);
if ((inputJSON.has("sessionID"))
&& UsersController.checkLogin(inputJSON.getString("sessionID"))) {
if (inputJSON.has("noteID"))
inputJSON.remove("noteID"); // na wszelki wypadek - chcemy generowaæ ID automatycznie
Note newNote = resolveNoteData(inputJSON);
hibernate.controllers.NotesController notesController =
new hibernate.controllers.NotesController();
if (newNote != null) notesController.addNote(newNote);
}
}
public void trapException(String output) throws CrowdFlowerException {
try {
JSONObject error = new JSONObject(output);
if (error.has("error")) {
throw new CrowdFlowerException(error.get("error").toString());
}
} catch (JSONException e) {
// ignore
}
}
private Note resolveNoteData(JSONObject inputJSON) {
if (!((inputJSON.has("noteTitle"))
&& (inputJSON.has("noteURL"))
&& (inputJSON.has("subjectID"))
&& (inputJSON.has("userID")))) {
return null;
} else {
try {
hibernate.controllers.SubjectsController subjectsController =
new hibernate.controllers.SubjectsController();
Subject subject =
subjectsController.readSubject(Integer.parseInt(inputJSON.get("subjectID").toString()));
hibernate.controllers.UsersController usersController =
new hibernate.controllers.UsersController();
User user = usersController.readUser(Integer.parseInt(inputJSON.get("userID").toString()));
return new Note(
inputJSON.getString("noteTitle"), inputJSON.getString("noteURL"), subject, user);
} catch (NullPointerException ex) {
return null;
}
}
}
@POST
@Path("/view/{id}")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public String viewNote(String inputData, @PathParam("id") int id) {
JSONObject inputJSON = new JSONObject(inputData);
if ((inputJSON.has("sessionID"))
&& UsersController.checkLogin(inputJSON.getString("sessionID"))) {
hibernate.controllers.NotesController notesController =
new hibernate.controllers.NotesController();
Note note = notesController.readNote(id);
if (note != null) {
JSONObject jsonNote = getJSONNote(note);
return jsonNote.toString();
} else {
return "No subject of ID == " + id + "!";
}
} else return "Invalid session!";
}
@DELETE
@Path("/{id}")
@Consumes(MediaType.APPLICATION_JSON)
@Produces("text/plain")
public String deleteNote(String inputData, @PathParam("id") int id) {
JSONObject inputJSON = new JSONObject(inputData);
if ((inputJSON.has("sessionID"))
&& UsersController.checkLogin(inputJSON.getString("sessionID"))) {
try {
hibernate.controllers.NotesController notesController =
new hibernate.controllers.NotesController();
notesController.deleteNote(id);
return "OK";
} catch (Exception ex) {
return ex.getMessage();
}
} else return "Invalid session!";
}
@POST
@Path("/view")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public String viewAllNotes(String inputData) {
JSONObject inputJSON = new JSONObject(inputData);
if ((inputJSON.has("sessionID"))
&& UsersController.checkLogin(inputJSON.getString("sessionID"))) {
hibernate.controllers.NotesController notesController =
new hibernate.controllers.NotesController();
List<Note> notes = notesController.readAllNotes();
JSONArray results = new JSONArray();
JSONObject jsonNote;
for (Note note : notes) {
jsonNote = getJSONNote(note);
results.put(jsonNote);
}
return results.toString();
} else return "Invalid session!";
}
@Before
public void synchronizeFeatureTypeAndLoadInfo() throws JSONException {
Layer layer = applicationLayer.getService().getSingleLayer(applicationLayer.getLayerName());
if (layer == null) {
getContext()
.getValidationErrors()
.addGlobalError(
new SimpleError(
"Laag niet gevonden bij originele service - verwijder deze laag uit niveau"));
return;
}
for (StyleLibrary sld : layer.getService().getStyleLibraries()) {
Map style = new HashMap();
JSONObject styleTitleJson = new JSONObject();
style.put("id", "sld:" + sld.getId());
style.put(
"title", "SLD stijl: " + sld.getTitle() + (sld.isDefaultStyle() ? " (standaard)" : ""));
// Find stuff for layerName
if (sld.getNamedLayerUserStylesJson() != null) {
JSONObject sldNamedLayerJson = new JSONObject(sld.getNamedLayerUserStylesJson());
if (sldNamedLayerJson.has(layer.getName())) {
JSONObject namedLayer = sldNamedLayerJson.getJSONObject(layer.getName());
if (namedLayer.has("title")) {
styleTitleJson.put("namedLayerTitle", namedLayer.get("title"));
}
JSONArray userStyles = namedLayer.getJSONArray("styles");
if (userStyles.length() > 0) {
JSONObject userStyle = userStyles.getJSONObject(0);
if (userStyle.has("title")) {
styleTitleJson.put("styleTitle", userStyle.get("title"));
}
}
}
}
styles.add(style);
stylesTitleJson.put((String) style.get("id"), styleTitleJson);
}
if (layer.getDetails().containsKey(Layer.DETAIL_WMS_STYLES)) {
JSONArray wmsStyles =
new JSONArray(layer.getDetails().get(Layer.DETAIL_WMS_STYLES).getValue());
for (int i = 0; i < wmsStyles.length(); i++) {
JSONObject wmsStyle = wmsStyles.getJSONObject(i);
Map style = new HashMap();
style.put("id", "wms:" + wmsStyle.getString("name"));
style.put(
"title",
"WMS server stijl: "
+ wmsStyle.getString("name")
+ " ("
+ wmsStyle.getString("title")
+ ")");
JSONObject styleTitleJson = new JSONObject();
styleTitleJson.put("styleTitle", wmsStyle.getString("title"));
styles.add(style);
stylesTitleJson.put((String) style.get("id"), styleTitleJson);
}
}
if (!styles.isEmpty()) {
List<Map> temp = new ArrayList();
Map s = new HashMap();
s.put("id", "registry_default");
s.put("title", "In gegevensregister als standaard ingestelde SLD");
temp.add(s);
s = new HashMap();
s.put("id", "none");
s.put("title", "Geen: standaard stijl van WMS service zelf");
temp.add(s);
temp.addAll(styles);
styles = temp;
}
// Synchronize configured attributes with layer feature type
if (layer.getFeatureType() == null || layer.getFeatureType().getAttributes().isEmpty()) {
applicationLayer.getAttributes().clear();
} else {
List<String> attributesToRetain = new ArrayList();
SimpleFeatureType sft = layer.getFeatureType();
editable = sft.isWriteable();
// Rebuild ApplicationLayer.attributes according to Layer FeatureType
// New attributes are added at the end of the list; the original
// order is only used when the Application.attributes list is empty
// So a feature for reordering attributes per applicationLayer is
// possible.
// New Attributes from a join or related featureType are added at the
// end of the list.
attributesToRetain = rebuildAttributes(sft);
// JSON info about attributed required for editing
makeAttributeJSONArray(layer.getFeatureType());
// Remove ConfiguredAttributes which are no longer present
List<ConfiguredAttribute> attributesToRemove = new ArrayList();
for (ConfiguredAttribute ca : applicationLayer.getAttributes()) {
if (ca.getFeatureType() == null) {
ca.setFeatureType(layer.getFeatureType());
}
if (!attributesToRetain.contains(ca.getFullName())) {
// Do not modify list we are iterating over
attributesToRemove.add(ca);
if (!"save".equals(getContext().getEventName())) {
getContext()
.getMessages()
.add(
new SimpleMessage(
"Attribuut \"{0}\" niet meer beschikbaar in attribuutbron: wordt verwijderd na opslaan",
ca.getAttributeName()));
}
}
}
for (ConfiguredAttribute ca : attributesToRemove) {
applicationLayer.getAttributes().remove(ca);
Stripersist.getEntityManager().remove(ca);
}
}
}
public Resolution save() throws JSONException {
// Only remove details which are editable and re-added layer if not empty,
// retain other details possibly used in other parts than this page
// See JSP for which keys are edited
applicationLayer
.getDetails()
.keySet()
.removeAll(
Arrays.asList(
"titleAlias",
"legendImageUrl",
"transparency",
"influenceradius",
"summary.title",
"summary.image",
"summary.description",
"summary.link",
"editfunction.title",
"style",
"summary.noHtmlEncode",
"summary.nl2br"));
for (Map.Entry<String, String> e : details.entrySet()) {
if (e.getValue() != null) { // Don't insert null value ClobElement
applicationLayer.getDetails().put(e.getKey(), new ClobElement(e.getValue()));
}
}
applicationLayer.getReaders().clear();
for (String groupName : groupsRead) {
applicationLayer.getReaders().add(groupName);
}
applicationLayer.getWriters().clear();
for (String groupName : groupsWrite) {
applicationLayer.getWriters().add(groupName);
}
if (applicationLayer.getAttributes() != null && applicationLayer.getAttributes().size() > 0) {
List<ConfiguredAttribute> appAttributes = applicationLayer.getAttributes();
int i = 0;
for (Iterator it = appAttributes.iterator(); it.hasNext(); ) {
ConfiguredAttribute appAttribute = (ConfiguredAttribute) it.next();
// save visible
if (selectedAttributes.contains(appAttribute.getFullName())) {
appAttribute.setVisible(true);
} else {
appAttribute.setVisible(false);
}
// save editable
if (attributesJSON.length() > i) {
JSONObject attribute = attributesJSON.getJSONObject(i);
if (attribute.has("editable")) {
appAttribute.setEditable(new Boolean(attribute.get("editable").toString()));
}
if (attribute.has("editalias")) {
appAttribute.setEditAlias(attribute.get("editalias").toString());
}
if (attribute.has("editvalues")) {
appAttribute.setEditValues(attribute.get("editvalues").toString());
}
if (attribute.has("editHeight")) {
appAttribute.setEditHeight(attribute.get("editHeight").toString());
}
// save selectable
if (attribute.has("selectable")) {
appAttribute.setSelectable(new Boolean(attribute.get("selectable").toString()));
}
if (attribute.has("filterable")) {
appAttribute.setFilterable(new Boolean(attribute.get("filterable").toString()));
}
if (attribute.has("defaultValue")) {
appAttribute.setDefaultValue(attribute.get("defaultValue").toString());
}
}
i++;
}
}
Stripersist.getEntityManager().persist(applicationLayer);
application.authorizationsModified();
displayName = applicationLayer.getDisplayName();
Stripersist.getEntityManager().getTransaction().commit();
getContext().getMessages().add(new SimpleMessage("De kaartlaag is opgeslagen"));
return edit();
}
public void doProcess(HttpServletRequest req, HttpServletResponse res, boolean isPost) {
StringBuffer bodyContent = null;
OutputStream out = null;
PrintWriter writer = null;
String serviceKey = null;
try {
BufferedReader in = req.getReader();
String line = null;
while ((line = in.readLine()) != null) {
if (bodyContent == null) bodyContent = new StringBuffer();
bodyContent.append(line);
}
} catch (Exception e) {
}
try {
if (requireSession) {
// check to see if there was a session created for this request
// if not assume it was from another domain and blow up
// Wrap this to prevent Portlet exeptions
HttpSession session = req.getSession(false);
if (session == null) {
res.setStatus(HttpServletResponse.SC_FORBIDDEN);
return;
}
}
serviceKey = req.getParameter("id");
// only to preven regressions - Remove before 1.0
if (serviceKey == null) serviceKey = req.getParameter("key");
// check if the services have been loaded or if they need to be reloaded
if (services == null || configUpdated()) {
getServices(res);
}
String urlString = null;
String xslURLString = null;
String userName = null;
String password = null;
String format = "json";
String callback = req.getParameter("callback");
String urlParams = req.getParameter("urlparams");
String countString = req.getParameter("count");
// encode the url to prevent spaces from being passed along
if (urlParams != null) {
urlParams = urlParams.replace(' ', '+');
}
try {
if (services.has(serviceKey)) {
JSONObject service = services.getJSONObject(serviceKey);
// default to the service default if no url parameters are specified
if (urlParams == null && service.has("defaultURLParams")) {
urlParams = service.getString("defaultURLParams");
}
String serviceURL = service.getString("url");
// build the URL
if (urlParams != null && serviceURL.indexOf("?") == -1) {
serviceURL += "?";
} else if (urlParams != null) {
serviceURL += "&";
}
String apikey = "";
if (service.has("username")) userName = service.getString("username");
if (service.has("password")) password = service.getString("password");
if (service.has("apikey")) apikey = service.getString("apikey");
urlString = serviceURL + apikey;
if (urlParams != null) urlString += "&" + urlParams;
if (service.has("xslStyleSheet")) {
xslURLString = service.getString("xslStyleSheet");
}
}
// code for passing the url directly through instead of using configuration file
else if (req.getParameter("url") != null) {
String serviceURL = req.getParameter("url");
// build the URL
if (urlParams != null && serviceURL.indexOf("?") == -1) {
serviceURL += "?";
} else if (urlParams != null) {
serviceURL += "&";
}
urlString = serviceURL;
if (urlParams != null) urlString += urlParams;
} else {
writer = res.getWriter();
if (serviceKey == null)
writer.write("XmlHttpProxyServlet Error: id parameter specifying serivce required.");
else
writer.write(
"XmlHttpProxyServlet Error : service for id '" + serviceKey + "' not found.");
writer.flush();
return;
}
} catch (Exception ex) {
getLogger().severe("XmlHttpProxyServlet Error loading service: " + ex);
}
Map paramsMap = new HashMap();
paramsMap.put("format", format);
// do not allow for xdomain unless the context level setting is enabled.
if (callback != null && allowXDomain) {
paramsMap.put("callback", callback);
}
if (countString != null) {
paramsMap.put("count", countString);
}
InputStream xslInputStream = null;
if (urlString == null) {
writer = res.getWriter();
writer.write(
"XmlHttpProxyServlet parameters: id[Required] urlparams[Optional] format[Optional] callback[Optional]");
writer.flush();
return;
}
// default to JSON
res.setContentType(responseContentType);
out = res.getOutputStream();
// get the stream for the xsl stylesheet
if (xslURLString != null) {
// check the web root for the resource
URL xslURL = null;
xslURL = ctx.getResource(resourcesDir + "xsl/" + xslURLString);
// if not in the web root check the classpath
if (xslURL == null) {
xslURL =
XmlHttpProxyServlet.class.getResource(classpathResourcesDir + "xsl/" + xslURLString);
}
if (xslURL != null) {
xslInputStream = xslURL.openStream();
} else {
String message =
"Could not locate the XSL stylesheet provided for service id "
+ serviceKey
+ ". Please check the XMLHttpProxy configuration.";
getLogger().severe(message);
try {
out.write(message.getBytes());
out.flush();
return;
} catch (java.io.IOException iox) {
}
}
}
if (!isPost) {
xhp.doGet(urlString, out, xslInputStream, paramsMap, userName, password);
} else {
if (bodyContent == null)
getLogger()
.info(
"XmlHttpProxyServlet attempting to post to url "
+ urlString
+ " with no body content");
xhp.doPost(
urlString,
out,
xslInputStream,
paramsMap,
bodyContent.toString(),
req.getContentType(),
userName,
password);
}
} catch (Exception iox) {
iox.printStackTrace();
getLogger().severe("XmlHttpProxyServlet: caught " + iox);
try {
writer = res.getWriter();
writer.write(iox.toString());
writer.flush();
} catch (java.io.IOException ix) {
ix.printStackTrace();
}
return;
} finally {
try {
if (out != null) out.close();
if (writer != null) writer.close();
} catch (java.io.IOException iox) {
}
}
}
/**
* Enrich portClassHier with class/interface names that map to a list of parent
* classes/interfaces. For any class encountered, find its parents too.<br>
* Also find the port types which have assignable schema classes.
*
* @param oper Operator to work on
* @param portClassHierarchy In-Out param that contains a mapping of class/interface to its
* parents
* @param portTypesWithSchemaClasses Json that will contain all the ports which have any schema
* classes.
*/
public void buildAdditionalPortInfo(
JSONObject oper, JSONObject portClassHierarchy, JSONObject portTypesWithSchemaClasses) {
try {
JSONArray ports = oper.getJSONArray(OperatorDiscoverer.PORT_TYPE_INFO_KEY);
for (int i = 0; i < ports.length(); i++) {
JSONObject port = ports.getJSONObject(i);
String portType = port.optString("type");
if (portType == null) {
// skipping if port type is null
continue;
}
if (typeGraph.size() == 0) {
buildTypeGraph();
}
try {
// building port class hierarchy
LinkedList<String> queue = Lists.newLinkedList();
queue.add(portType);
while (!queue.isEmpty()) {
String currentType = queue.remove();
if (portClassHierarchy.has(currentType)) {
// already present in the json so we skip.
continue;
}
List<String> immediateParents = typeGraph.getParents(currentType);
if (immediateParents == null) {
portClassHierarchy.put(currentType, Lists.<String>newArrayList());
continue;
}
portClassHierarchy.put(currentType, immediateParents);
queue.addAll(immediateParents);
}
} catch (JSONException e) {
LOG.warn("building port type hierarchy {}", portType, e);
}
// finding port types with schema classes
if (portTypesWithSchemaClasses.has(portType)) {
// already present in the json so skipping
continue;
}
if (portType.equals("byte")
|| portType.equals("short")
|| portType.equals("char")
|| portType.equals("int")
|| portType.equals("long")
|| portType.equals("float")
|| portType.equals("double")
|| portType.equals("java.lang.String")
|| portType.equals("java.lang.Object")) {
// ignoring primitives, strings and object types as this information is needed only for
// complex types.
continue;
}
if (port.has("typeArgs")) {
// ignoring any type with generics
continue;
}
boolean hasSchemaClasses = false;
List<String> instantiableDescendants = typeGraph.getInstantiableDescendants(portType);
if (instantiableDescendants != null) {
for (String descendant : instantiableDescendants) {
try {
if (typeGraph.isInstantiableBean(descendant)) {
hasSchemaClasses = true;
break;
}
} catch (JSONException ex) {
LOG.warn("checking descendant is instantiable {}", descendant);
}
}
}
portTypesWithSchemaClasses.put(portType, hasSchemaClasses);
}
} catch (JSONException e) {
// should not reach this
LOG.error("JSON Exception {}", e);
throw new RuntimeException(e);
}
}
public JSONObject describeOperator(String clazz) throws Exception {
TypeGraphVertex tgv = typeGraph.getTypeGraphVertex(clazz);
if (tgv.isInstantiable()) {
JSONObject response = new JSONObject();
JSONArray inputPorts = new JSONArray();
JSONArray outputPorts = new JSONArray();
// Get properties from ASM
JSONObject operatorDescriptor = describeClassByASM(clazz);
JSONArray properties = operatorDescriptor.getJSONArray("properties");
properties = enrichProperties(clazz, properties);
JSONArray portTypeInfo = operatorDescriptor.getJSONArray("portTypeInfo");
List<CompactFieldNode> inputPortfields = typeGraph.getAllInputPorts(clazz);
List<CompactFieldNode> outputPortfields = typeGraph.getAllOutputPorts(clazz);
try {
for (CompactFieldNode field : inputPortfields) {
JSONObject inputPort = setFieldAttributes(clazz, field);
if (!inputPort.has("optional")) {
inputPort.put(
"optional",
false); // input port that is not annotated is default to be not optional
}
if (!inputPort.has(SCHEMA_REQUIRED_KEY)) {
inputPort.put(SCHEMA_REQUIRED_KEY, false);
}
inputPorts.put(inputPort);
}
for (CompactFieldNode field : outputPortfields) {
JSONObject outputPort = setFieldAttributes(clazz, field);
if (!outputPort.has("optional")) {
outputPort.put(
"optional", true); // output port that is not annotated is default to be optional
}
if (!outputPort.has("error")) {
outputPort.put("error", false);
}
if (!outputPort.has(SCHEMA_REQUIRED_KEY)) {
outputPort.put(SCHEMA_REQUIRED_KEY, false);
}
outputPorts.put(outputPort);
}
response.put("name", clazz);
response.put("properties", properties);
response.put(PORT_TYPE_INFO_KEY, portTypeInfo);
response.put("inputPorts", inputPorts);
response.put("outputPorts", outputPorts);
OperatorClassInfo oci = classInfo.get(clazz);
if (oci != null) {
if (oci.comment != null) {
String[] descriptions;
// first look for a <p> tag
String keptPrefix = "<p>";
descriptions = oci.comment.split("<p>", 2);
if (descriptions.length == 0) {
keptPrefix = "";
// if no <p> tag, then look for a blank line
descriptions = oci.comment.split("\n\n", 2);
}
if (descriptions.length > 0) {
response.put("shortDesc", descriptions[0]);
}
if (descriptions.length > 1) {
response.put("longDesc", keptPrefix + descriptions[1]);
}
}
response.put("category", oci.tags.get("@category"));
String displayName = oci.tags.get("@displayName");
if (displayName == null) {
displayName = decamelizeClassName(ClassUtils.getShortClassName(clazz));
}
response.put("displayName", displayName);
String tags = oci.tags.get("@tags");
if (tags != null) {
JSONArray tagArray = new JSONArray();
for (String tag : StringUtils.split(tags, ',')) {
tagArray.put(tag.trim().toLowerCase());
}
response.put("tags", tagArray);
}
String doclink = oci.tags.get("@doclink");
if (doclink != null) {
response.put("doclink", doclink + "?" + getDocName(clazz));
} else if (clazz.startsWith("com.datatorrent.lib.")
|| clazz.startsWith("com.datatorrent.contrib.")) {
response.put("doclink", DT_OPERATOR_DOCLINK_PREFIX + "?" + getDocName(clazz));
}
}
} catch (JSONException ex) {
throw new RuntimeException(ex);
}
return response;
} else {
throw new UnsupportedOperationException();
}
}
