public static void extractTranslation(final JSONWriter writer, final Resource translationResource)
throws JSONException, IOException {
final Iterable<Resource> translations = translationResource.getChildren();
final ValueMap props = translationResource.adaptTo(ValueMap.class);
String languageLabel = (String) props.get("language");
if (null == languageLabel) {
languageLabel = (String) props.get("mtlanguage");
if (null == languageLabel) {
return;
}
}
writer.key(ContentTypeDefinitions.LABEL_TRANSLATION);
writer.object();
writer.key("mtlanguage");
if (languageLabel.equals("nb")) {
// SPECIAL CASE FOR LEGACY EXPORTER ONLY:
// the label for norwegian changed between 6.0 and 6.1
// (i.e. this section must be removed for 6.1 exporter)
languageLabel = "no";
}
writer.value(languageLabel);
writer.key("jcr:created");
writer.value(props.get("jcr:created", Long.class));
writer.key("jcr:createdBy");
writer.value(props.get("jcr:createdBy"));
if (translations.iterator().hasNext()) {
writer.key(ContentTypeDefinitions.LABEL_TRANSLATIONS);
final JSONWriter translationObjects = writer.object();
UGCExportHelper.extractTranslations(translationObjects, translations);
writer.endObject();
}
writer.endObject();
}
public static void extractTally(
final JSONWriter responseArray, final Resource rootNode, final String tallyType)
throws JSONException, UnsupportedEncodingException {
final Map<String, Map<Long, ResponseValue>> responses = getTallyResponses(rootNode);
if (null != responses) {
for (final String userIdentifier : responses.keySet()) {
for (final Map.Entry<Long, ResponseValue> entry :
responses.get(userIdentifier).entrySet()) {
final JSONWriter voteObject = responseArray.object();
final String response = entry.getValue().getResponseValue();
voteObject.key("timestamp");
voteObject.value(entry.getKey());
voteObject.key("response");
voteObject.value(URLEncoder.encode(response, "UTF-8"));
voteObject.key("userIdentifier");
voteObject.value(URLEncoder.encode(userIdentifier, "UTF-8"));
if (tallyType != null) {
// for the purposes of this export, tallyType is fixed
voteObject.key("tallyType");
voteObject.value(tallyType);
}
voteObject.endObject();
}
}
}
}
public static void writeFileNode(
Content content,
org.sakaiproject.nakamura.api.lite.Session session,
JSONWriter write,
int maxDepth,
boolean objectInProgress)
throws JSONException, StorageClientException {
if (content == null) {
log.warn("Can't output null content.");
return;
}
if (!objectInProgress) {
write.object();
}
// dump all the properties.
ExtendedJSONWriter.writeContentTreeToWriter(write, content, true, maxDepth);
// The permissions for this session.
writePermissions(content, session, write);
write.key(JcrConstants.JCR_LASTMODIFIED);
Calendar cal = new GregorianCalendar();
cal.setTimeInMillis(StorageClientUtils.toLong(content.getProperty(Content.LASTMODIFIED_FIELD)));
write.value(DateUtils.iso8601(cal));
write.key(JcrConstants.JCR_MIMETYPE);
write.value(content.getProperty(Content.MIMETYPE_FIELD));
write.key(JcrConstants.JCR_DATA);
write.value(StorageClientUtils.toLong(content.getProperty(Content.LENGTH_FIELD)));
if (!objectInProgress) {
write.endObject();
}
}
/**
* Writes all the properties of a sakai/file node. Also checks what the permissions are for a
* session and where the links are.
*
* @param node
* @param write
* @param objectInProgress Whether object creation is in progress. If false, object is started and
* ended in this method call.
* @throws JSONException
* @throws RepositoryException
*/
public static void writeFileNode(Node node, Session session, JSONWriter write, int maxDepth)
throws JSONException, RepositoryException {
write.object();
// dump all the properties.
ExtendedJSONWriter.writeNodeTreeToWriter(write, node, true, maxDepth);
// The permissions for this session.
writePermissions(node, session, write);
if (node.hasNode(JcrConstants.JCR_CONTENT)) {
Node contentNode = node.getNode(JcrConstants.JCR_CONTENT);
write.key(JcrConstants.JCR_LASTMODIFIED);
Calendar cal = contentNode.getProperty(JcrConstants.JCR_LASTMODIFIED).getDate();
write.value(DateUtils.iso8601(cal));
write.key(JcrConstants.JCR_MIMETYPE);
write.value(contentNode.getProperty(JcrConstants.JCR_MIMETYPE).getString());
if (contentNode.hasProperty(JcrConstants.JCR_DATA)) {
write.key(JcrConstants.JCR_DATA);
write.value(contentNode.getProperty(JcrConstants.JCR_DATA).getLength());
}
}
write.endObject();
}
private static void writePermissions(
Content content, org.sakaiproject.nakamura.api.lite.Session session, JSONWriter writer)
throws StorageClientException, JSONException {
if (content == null) {
log.warn("Can't output permissions of null content.");
return;
}
AccessControlManager acm = session.getAccessControlManager();
String path = content.getPath();
writer.key("permissions");
writer.object();
writer.key("set_property");
// TODO does CAN_WRITE == set_property -CFH : yes, ieb
// TODO: make this a bit more efficient, checking permissions one by one is going to rely on
// caching to make it efficient. It would be better to get the permissions bitmap and then
// check it to see what has been set. That might require a niew methods in the
// AccessControl
// manager API.
writer.value(hasPermission(acm, path, Permissions.CAN_WRITE));
writer.key("read");
writer.value(hasPermission(acm, path, Permissions.CAN_READ));
writer.key("remove");
writer.value(hasPermission(acm, path, Permissions.CAN_DELETE));
writer.endObject();
}
public void writeResults(
SlingHttpServletRequest request, JSONWriter write, Iterator<Result> results)
throws JSONException {
ExtendedJSONWriter exWriter = (ExtendedJSONWriter) write;
Session session =
StorageClientUtils.adaptToSession(
request.getResourceResolver().adaptTo(javax.jcr.Session.class));
String currUser = request.getRemoteUser();
try {
// write out the profile information for each result
while (results.hasNext()) {
Result result = results.next();
// start the object here so we can decorate with contact details
write.object();
super.writeResult(request, write, result, true);
// add contact information if appropriate
String otherUser = String.valueOf(result.getFirstValue("path"));
connMgr.writeConnectionInfo(exWriter, session, currUser, otherUser);
write.endObject();
}
} catch (StorageClientException e) {
LOGGER.error(e.getMessage(), e);
} catch (AccessDeniedException e) {
LOGGER.error(e.getMessage(), e);
}
}
private void writeResponse(
JSONWriter write, ResponseWrapper responseWrapper, RequestInfo requestData)
throws JSONException {
try {
String body = responseWrapper.getDataAsString();
write.object();
write.key("url");
write.value(requestData.getUrl());
write.key("success");
write.value(true);
write.key("body");
write.value(body);
write.key("status");
write.value(responseWrapper.getResponseStatus());
write.key("headers");
write.object();
Dictionary<String, String> headers = responseWrapper.getResponseHeaders();
Enumeration<String> keys = headers.keys();
while (keys.hasMoreElements()) {
String k = keys.nextElement();
write.key(k);
write.value(headers.get(k));
}
write.endObject();
write.endObject();
} catch (UnsupportedEncodingException e) {
writeFailedRequest(write, requestData);
}
}
/** Dump given node in JSON, optionally recursing into its child nodes */
protected void dump(Node node, JSONWriter w, int currentRecursionLevel, int maxRecursionLevels)
throws RepositoryException, JSONException {
w.object();
PropertyIterator props = node.getProperties();
// the node's actual properties
while (props.hasNext()) {
Property prop = props.nextProperty();
if (propertyNamesToIgnore != null && propertyNamesToIgnore.contains(prop.getName())) {
continue;
}
writeProperty(w, prop);
}
// the child nodes
if (recursionLevelActive(currentRecursionLevel, maxRecursionLevels)) {
final NodeIterator children = node.getNodes();
while (children.hasNext()) {
final Node n = children.nextNode();
dumpSingleNode(n, w, currentRecursionLevel, maxRecursionLevels);
}
}
w.endObject();
}
public static void extractSubNode(JSONWriter object, final Resource node) throws JSONException {
final ValueMap childVm = node.adaptTo(ValueMap.class);
extractProperties(object, childVm);
final Iterable<Resource> childNodes = node.getChildren();
if (childNodes != null) {
object.key(ContentTypeDefinitions.LABEL_SUBNODES);
object.object();
for (final Resource subNode : childNodes) {
object.key(subNode.getName());
JSONWriter subObject = object.object();
extractSubNode(subObject, subNode);
object.endObject();
}
object.endObject();
}
}
/** Dump given property in JSON */
public void dump(Property p, Writer w)
throws JSONException, ValueFormatException, RepositoryException {
final JSONWriter jw = new JSONWriter(w);
jw.object();
writeProperty(jw, p);
jw.endObject();
}
public static void writeLinkNode(
Content content,
org.sakaiproject.nakamura.api.lite.Session session,
JSONWriter writer,
boolean objectInProgress)
throws StorageClientException, JSONException {
if (!objectInProgress) {
writer.object();
}
ContentManager contentManager = session.getContentManager();
// Write all the properties.
ExtendedJSONWriter.writeNodeContentsToWriter(writer, content);
// permissions
writePermissions(content, session, writer);
// Write the actual file.
if (content.hasProperty(SAKAI_LINK)) {
String linkPath = (String) content.getProperty(SAKAI_LINK);
writer.key("file");
try {
Content fileNode = contentManager.get(linkPath);
writeFileNode(fileNode, session, writer);
} catch (org.sakaiproject.nakamura.api.lite.accesscontrol.AccessDeniedException e) {
writer.value(false);
}
}
if (!objectInProgress) {
writer.endObject();
}
}
public void writeResult(SlingHttpServletRequest request, JSONWriter write, Result result)
throws JSONException {
String contentPath = result.getPath();
Session session =
StorageClientUtils.adaptToSession(
request.getResourceResolver().adaptTo(javax.jcr.Session.class));
try {
Content contentResult = session.getContentManager().get(contentPath);
if (contentResult != null) {
write.object();
writeCanManageProperty(request, write, session, contentResult);
writeCommentCountProperty(write, session, contentResult);
int depth = SolrSearchUtil.getTraversalDepth(request);
ExtendedJSONWriter.writeContentTreeToWriter(write, contentResult, true, depth);
write.endObject();
}
} catch (AccessDeniedException ade) {
// if access is denied we simply won't
// write anything for this result
// this implies content was private
LOGGER.info("Denied {} access to {}", request.getRemoteUser(), contentPath);
return;
} catch (Exception e) {
throw new JSONException(e);
}
}
private void writeFailedRequest(JSONWriter write, RequestInfo requestData) throws JSONException {
write.object();
write.key("url");
write.value(requestData.getUrl());
write.key("success");
write.value(false);
write.endObject();
}
/**
* Gives the permissions for this user.
*
* @param node
* @param session
* @param write
* @throws RepositoryException
* @throws JSONException
*/
private static void writePermissions(Node node, Session session, JSONWriter write)
throws RepositoryException, JSONException {
String path = node.getPath();
write.key("permissions");
write.object();
write.key("set_property");
write.value(hasPermission(session, path, "set_property"));
write.key("read");
write.value(hasPermission(session, path, "read"));
write.key("remove");
write.value(hasPermission(session, path, "remove"));
write.endObject();
}
public static void extractTranslations(
final JSONWriter writer, final Iterable<Resource> translations)
throws JSONException, IOException {
for (final Resource translation : translations) {
final JSONArray timestampFields = new JSONArray();
final ValueMap vm = translation.adaptTo(ValueMap.class);
if (!vm.containsKey("jcr:description")) {
continue; // if there's no translation, we're done here
}
String languageLabel = translation.getName();
if (languageLabel.equals("nb")) {
// SPECIAL CASE FOR LEGACY EXPORTER ONLY:
// the label for norwegian changed between 6.0 and 6.1
// (i.e. this section must be removed for 6.1 exporter)
languageLabel = "no";
}
writer.key(languageLabel);
JSONWriter translationObject = writer.object();
translationObject.key("jcr:description");
translationObject.value(URLEncoder.encode((String) vm.get("jcr:description"), "UTF-8"));
if (vm.containsKey("jcr:createdBy")) {
translationObject.key("jcr:createdBy");
translationObject.value(URLEncoder.encode((String) vm.get("jcr:createdBy"), "UTF-8"));
}
if (vm.containsKey("jcr:title")) {
translationObject.key("jcr:title");
translationObject.value(URLEncoder.encode((String) vm.get("jcr:title"), "UTF-8"));
}
if (vm.containsKey("postEdited")) {
translationObject.key("postEdited");
translationObject.value(vm.get("postEdited"));
}
if (vm.containsKey("translationDate")) {
translationObject.key("translationDate");
translationObject.value(((Calendar) vm.get("translationDate")).getTimeInMillis());
timestampFields.put("translationDate");
}
if (vm.containsKey("jcr:created")) {
translationObject.key("jcr:created");
translationObject.value(((Calendar) vm.get("jcr:created")).getTimeInMillis());
timestampFields.put("jcr:created");
}
if (timestampFields.length() > 0) {
translationObject.key(ContentTypeDefinitions.LABEL_TIMESTAMP_FIELDS);
translationObject.value(timestampFields);
}
translationObject.endObject();
}
}
/**
* Give a JSON representation of the content.
*
* @param content
* @param session
* @param write The {@link JSONWriter} to output to.
* @param depth
* @throws JSONException
* @throws StorageClientException
*/
protected void handleContent(
final Content content, final Session session, final JSONWriter write, final int depth)
throws JSONException, StorageClientException {
write.object();
final String type = (String) content.getProperty(SLING_RESOURCE_TYPE_PROPERTY);
if (FilesConstants.RT_SAKAI_LINK.equals(type)) {
FileUtils.writeLinkNode(content, session, write, true);
} else {
FileUtils.writeFileNode(content, session, write, depth, true);
}
FileUtils.writeComments(content, session, write);
FileUtils.writeCommentCountProperty(content, session, write, repository);
write.endObject();
}
private void writeNode(
SlingHttpServletRequest request, JSONWriter write, Aggregator aggregator, Row row)
throws JSONException, RepositoryException {
Session session = request.getResourceResolver().adaptTo(Session.class);
Node node = RowUtils.getNode(row, session);
Node siteNode = node;
boolean foundSite = false;
while (!siteNode.getPath().equals("/")) {
if (siteService.isSite(siteNode)) {
foundSite = true;
break;
}
siteNode = siteNode.getParent();
}
if (foundSite) {
if (node.hasProperty(SLING_RESOURCE_TYPE_PROPERTY)) {
String type = node.getProperty(SLING_RESOURCE_TYPE_PROPERTY).getString();
// From looking at the type we determine how we should represent this node.
SearchResultProcessor processor = tracker.getSearchResultProcessorByType(type);
if (processor != null) {
write.object();
write.key("path");
write.value(node.getPath());
write.key("site");
siteSearchResultProcessor.writeNode(write, siteNode);
write.key("type");
write.value(node.getProperty(SLING_RESOURCE_TYPE_PROPERTY).getString());
write.key("excerpt");
write.value(RowUtils.getDefaultExcerpt(row));
write.key("data");
processor.writeNode(request, write, aggregator, row);
write.endObject();
} else {
// No processor found, just dump the properties
writeDefaultNode(write, aggregator, row, siteNode, session);
}
} else {
// No type, just dump the properties
writeDefaultNode(write, aggregator, row, siteNode, session);
}
}
}
private void writeReplicationState(JSONWriter out, Resource resource) throws Exception {
out.key("replication").object();
ReplicationStatus replicationStatus = resource.adaptTo(ReplicationStatus.class);
if (replicationStatus != null) {
Calendar published = replicationStatus.getLastPublished();
if (published != null) {
out.key("published").value(published.getTimeInMillis());
}
if (replicationStatus.getLastReplicationAction() != null) {
String action = replicationStatus.getLastReplicationAction().name();
if (action != null && action.length() > 0) {
out.key("action").value(action);
}
}
}
out.endObject();
}
/**
* {@inheritDoc}
*
* @see
* org.sakaiproject.nakamura.api.search.SearchResultProcessor#writeNode(org.apache.sling.api.SlingHttpServletRequest,
* org.apache.sling.commons.json.io.JSONWriter,
* org.sakaiproject.nakamura.api.search.Aggregator, javax.jcr.query.Row)
*/
public void writeNode(
SlingHttpServletRequest request, JSONWriter write, Aggregator aggregator, Row row)
throws JSONException, RepositoryException {
write.object();
Node node = row.getNode();
write.key("jcr:created");
write.value(node.getProperty("jcr:created").getString());
String userID = node.getName();
UserManager um = AccessControlUtil.getUserManager(node.getSession());
Authorizable au = um.getAuthorizable(userID);
if (au != null) {
ValueMap map = profileService.getCompactProfileMap(au, node.getSession());
((ExtendedJSONWriter) write).valueMapInternals(map);
}
write.endObject();
}
/**
* Same as writeResults logic, but counts number of results iterated over.
*
* @param request
* @param write
* @param iterator
* @return Set containing all unique paths processed.
* @throws JSONException
*/
public Set<String> writeResultsInternal(
SlingHttpServletRequest request, JSONWriter write, Iterator<Result> iterator)
throws JSONException {
final Set<String> uniquePaths = new HashSet<String>();
final Integer iDepth = (Integer) request.getAttribute("depth");
int depth = 0;
if (iDepth != null) {
depth = iDepth.intValue();
}
try {
javax.jcr.Session jcrSession = request.getResourceResolver().adaptTo(javax.jcr.Session.class);
final Session session = StorageClientUtils.adaptToSession(jcrSession);
while (iterator.hasNext()) {
final Result result = iterator.next();
uniquePaths.add(result.getPath());
try {
if ("authorizable".equals(result.getFirstValue("resourceType"))) {
AuthorizableManager authManager = session.getAuthorizableManager();
Authorizable auth = authManager.findAuthorizable((String) result.getFirstValue("id"));
if (auth != null) {
write.object();
ValueMap map = profileService.getProfileMap(auth, jcrSession);
ExtendedJSONWriter.writeValueMapInternals(write, map);
write.endObject();
}
} else {
String contentPath = result.getPath();
final Content content = session.getContentManager().get(contentPath);
if (content != null) {
handleContent(content, session, write, depth);
} else {
LOGGER.debug("Found null content item while writing results [{}]", contentPath);
}
}
} catch (AccessDeniedException e) {
// do nothing
} catch (RepositoryException e) {
throw new JSONException(e);
}
}
} catch (StorageClientException e) {
throw new JSONException(e);
}
return uniquePaths;
}
/**
* Takes the original request and starts the batching.
*
* @param request
* @param response
* @throws IOException
*/
protected void batchRequest(
SlingHttpServletRequest request, SlingHttpServletResponse response, boolean allowModify)
throws IOException {
// Grab the JSON block out of it and convert it to RequestData objects we can use.
String json = request.getParameter(REQUESTS_PARAMETER);
List<RequestInfo> batchedRequests = new ArrayList<RequestInfo>();
try {
JSONArray arr = new JSONArray(json);
for (int i = 0; i < arr.length(); i++) {
JSONObject obj = arr.getJSONObject(i);
RequestInfo r = new RequestInfo(obj);
if (allowModify || r.isSafe()) {
batchedRequests.add(r);
}
}
} catch (JSONException e) {
response.sendError(
HttpServletResponse.SC_BAD_REQUEST,
"Failed to parse the " + REQUESTS_PARAMETER + " parameter");
LOGGER.warn("Failed to parse the " + REQUESTS_PARAMETER + " parameter");
return;
}
// Loop over the requests and handle each one.
try {
StringWriter sw = new StringWriter();
JSONWriter write = new JSONWriter(sw);
write.object();
write.key("results");
write.array();
for (RequestInfo r : batchedRequests) {
doRequest(request, response, r, write);
}
write.endArray();
write.endObject();
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");
response.getWriter().write(sw.getBuffer().toString());
} catch (JSONException e) {
LOGGER.warn("Failed to create a JSON response");
response.sendError(
HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Failed to write JSON response");
}
}
private void writeDefaultNode(
JSONWriter write, Aggregator aggregator, Row row, Node siteNode, Session session)
throws JSONException, RepositoryException {
Node node = RowUtils.getNode(row, session);
if (aggregator != null) {
aggregator.add(node);
}
write.object();
write.key("path");
write.value(node.getPath());
write.key("site");
siteSearchResultProcessor.writeNode(write, siteNode);
write.key("excerpt");
write.value(RowUtils.getDefaultExcerpt(row));
write.key("data");
ExtendedJSONWriter.writeNodeToWriter(write, node);
write.endObject();
}
/**
* Writes comments of content
*
* @param node
* @param session
* @param write
* @throws RepositoryException
* @throws JSONException
*/
public static void writeComments(
Content content, org.sakaiproject.nakamura.api.lite.Session session, JSONWriter writer)
throws StorageClientException, JSONException {
if (content == null) {
log.warn("Can't output comments of null content.");
return;
}
writer.key("comments");
writer.object();
Content commentContent = null;
try {
commentContent = session.getContentManager().get(content.getPath() + "/comments");
ExtendedJSONWriter.writeContentTreeToWriter(writer, commentContent, true, 2);
} catch (org.sakaiproject.nakamura.api.lite.accesscontrol.AccessDeniedException e) {
writer.value(false);
} finally {
writer.endObject();
}
}
/**
* Writes all the properties for a linked node.
*
* @param node
* @param write
* @throws JSONException
* @throws RepositoryException
*/
public static void writeLinkNode(Node node, Session session, JSONWriter write)
throws JSONException, RepositoryException {
write.object();
// Write all the properties.
ExtendedJSONWriter.writeNodeContentsToWriter(write, node);
// permissions
writePermissions(node, session, write);
// Write the actual file.
if (node.hasProperty(SAKAI_LINK)) {
String uuid = node.getProperty(SAKAI_LINK).getString();
write.key("file");
try {
Node fileNode = session.getNodeByIdentifier(uuid);
writeFileNode(fileNode, session, write);
} catch (ItemNotFoundException e) {
write.value(false);
}
}
write.endObject();
}
/**
* Represent an entire JCR tree in JSON format.
*
* @param write The {@link JSONWriter writer} to send the data to.
* @param node The node and it's subtree to output. Note: The properties of this node will be
* outputted as well.
* @param objectInProgress use true if you don't want the method to enclose the output in fresh
* object braces
* @param maxDepth Maximum depth of subnodes to traverse. The properties on {@link node} are
* processed before this is taken into account.
* @param currentLevel Internal parameter to track the current processing level.
* @throws RepositoryException
* @throws JSONException
*/
protected static void writeNodeTreeToWriter(
JSONWriter write, Node node, boolean objectInProgress, int maxDepth, int currentLevel)
throws RepositoryException, JSONException {
// Write this node's properties.
if (!objectInProgress) {
write.object();
}
writeNodeContentsToWriter(write, node);
if (maxDepth == -1 || currentLevel < maxDepth) {
// Write all the child nodes.
NodeIterator iterator = node.getNodes();
while (iterator.hasNext()) {
Node childNode = iterator.nextNode();
write.key(childNode.getName());
writeNodeTreeToWriter(write, childNode, false, maxDepth, currentLevel + 1);
}
}
if (!objectInProgress) {
write.endObject();
}
}
public void write(JSONWriter writer) throws JSONException {
writer.object();
writer.key("xtype").value("tbseparator");
writer.endObject();
}
public void write(JSONWriter writer) throws JSONException {
writer.object();
writer.key("xtype").value("tbtext");
writer.key("text").value(text);
writer.endObject();
}
/**
* {@inheritDoc}
*
* @see
* org.apache.sling.api.servlets.SlingAllMethodsServlet#doPost(org.apache.sling.api.SlingHttpServletRequest,
* org.apache.sling.api.SlingHttpServletResponse)
*/
@Override
protected void doPost(SlingHttpServletRequest request, SlingHttpServletResponse response)
throws ServletException, IOException {
// Check if the current user is logged in.
if (request.getRemoteUser().equals("anonymous")) {
response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "Anonymous user cannot crop images.");
return;
}
RequestParameter imgParam = request.getRequestParameter("img");
RequestParameter saveParam = request.getRequestParameter("save");
RequestParameter xParam = request.getRequestParameter("x");
RequestParameter yParam = request.getRequestParameter("y");
RequestParameter widthParam = request.getRequestParameter("width");
RequestParameter heightParam = request.getRequestParameter("height");
RequestParameter dimensionsParam = request.getRequestParameter("dimensions");
if (imgParam == null
|| saveParam == null
|| xParam == null
|| yParam == null
|| widthParam == null
|| heightParam == null
|| dimensionsParam == null) {
response.sendError(
HttpServletResponse.SC_BAD_REQUEST,
"The following parameters are required: img, save, x, y, width, height, dimensions");
return;
}
try {
// Grab the session
ResourceResolver resourceResolver = request.getResourceResolver();
Session session = resourceResolver.adaptTo(Session.class);
String img = imgParam.getString();
String save = saveParam.getString();
int x = Integer.parseInt(xParam.getString());
int y = Integer.parseInt(yParam.getString());
int width = Integer.parseInt(widthParam.getString());
int height = Integer.parseInt(heightParam.getString());
String[] dimensionsList = StringUtils.split(dimensionsParam.getString(), ';');
List<Dimension> dimensions = new ArrayList<Dimension>();
for (String s : dimensionsList) {
Dimension d = new Dimension();
String[] size = StringUtils.split(s, 'x');
int diWidth = Integer.parseInt(size[0]);
int diHeight = Integer.parseInt(size[1]);
diWidth = checkIntBiggerThanZero(diWidth, 0);
diHeight = checkIntBiggerThanZero(diHeight, 0);
d.setSize(diWidth, diHeight);
dimensions.add(d);
}
x = checkIntBiggerThanZero(x, 0);
y = checkIntBiggerThanZero(y, 0);
width = checkIntBiggerThanZero(width, 0);
height = checkIntBiggerThanZero(height, 0);
// Make sure the save path is correct.
save = PathUtils.normalizePath(save) + "/";
String[] crop = CropItProcessor.crop(session, x, y, width, height, dimensions, img, save);
JSONWriter output = new JSONWriter(response.getWriter());
output.object();
output.key("files");
output.array();
for (String url : crop) {
output.value(url);
}
output.endArray();
output.endObject();
} catch (ArrayIndexOutOfBoundsException e) {
response.sendError(
HttpServletResponse.SC_BAD_REQUEST,
"The dimensions have to be specified in a widthxheight;widthxheight fashion.");
return;
} catch (NumberFormatException e) {
response.sendError(
HttpServletResponse.SC_BAD_REQUEST,
"The following parameters have to be integers: x, y, width, height. (Dimensions has to be of the form widthxheight;widthxheight");
return;
} catch (ImageException e) {
// Something went wrong..
logger.warn("ImageException e: " + e.getMessage());
response.sendError(e.getCode(), e.getMessage());
} catch (JSONException e) {
response.sendError(500, "Unable to output JSON.");
}
}
protected void dump(Node node, JSONWriter w, int currentRecursionLevel, int maxRecursionLevels)
throws RepositoryException, JSONException {
// check for array
boolean isArray = true;
NodeIterator children = node.getNodes();
if (!children.hasNext()) { // has no children
isArray = false;
}
while (children.hasNext()) {
final Node n = children.nextNode();
if (!n.getName().matches("\\d+")) {
isArray = false;
break;
}
}
PropertyIterator props = node.getProperties();
if (isArray && props.hasNext()) {
// array should not have properties
while (props.hasNext()) {
Property prop = props.nextProperty();
// ignore any jcr:* properties
if (!prop.getName().matches("jcr:.+")) {
isArray = false;
break;
}
}
}
if (isArray) {
w.array();
// the child nodes
if (recursionLevelActive(currentRecursionLevel, maxRecursionLevels)) {
children = node.getNodes();
while (children.hasNext()) {
final Node n = children.nextNode();
dump(n, w, currentRecursionLevel + 1, maxRecursionLevels);
}
}
w.endArray();
} else {
w.object();
props = node.getProperties();
// the node's actual properties
while (props.hasNext()) {
Property prop = props.nextProperty();
if (prop.getName().matches("jcr:.+")) { // ignore any jcr:* properties
continue;
}
if (prop.getName().matches("cq:.+")) { // ignore any cq:* properties
continue;
}
writeProperty(w, prop);
}
// the child nodes
if (recursionLevelActive(currentRecursionLevel, maxRecursionLevels)) {
children = node.getNodes();
while (children.hasNext()) {
final Node n = children.nextNode();
dumpSingleNode(n, w, currentRecursionLevel, maxRecursionLevels);
}
}
w.endObject();
}
}
/**
* Write the given resource list as JSON array to the output.
*
* @param out writer
* @param list list of resources
* @param orderable whether the list of resources is orderable.
* @param numChildrenCheck the maximum number of children to check whether it matches the
* predicate.
* @throws JSONException if a JSON error occurs
*/
private void write(JSONWriter out, List<Resource> list, boolean orderable, int numChildrenCheck)
throws JSONException {
out.array();
List<Resource> oList = orderable ? list : orderList(list);
for (Resource resource : oList) {
out.object();
LabeledResource lr = resource.adaptTo(LabeledResource.class);
String name = Text.getName(resource.getPath());
out.key("name").value(name);
String text;
if (lr == null) {
text = name;
} else {
text = (lr.getTitle() == null) ? name : lr.getTitle();
if (lr.getDescription() != null) {
out.key("description").value(lr.getDescription());
}
}
if (text != null) {
text = text.replaceAll("<", "<");
}
out.key("text").value(text);
out.key("type").value(resource.getResourceType());
int children = countChildren(resource, numChildrenCheck);
boolean hasChildren = children > 0;
// write CSS class information according to presence of children.
// this should probably be done via the 'type' attribute above in
// the widget itself
out.key("cls").value(hasChildren ? "folder" : "file");
if (!hasChildren) {
out.key("leaf").value(true);
} else {
out.key("sub").value(children);
}
try {
Node node = resource.adaptTo(Node.class);
String dpsType = DPSUtil.getDPSResourceType(node);
out.key(DPSConstants.PN_DPS_RESOURCE_TYPE).value(dpsType);
if (dpsType != null) {
out.key("uiProvider").value("publishingNodeUI");
out.key("dpsType").value(dpsType);
DPSArticle article = resource.adaptTo(DPSArticle.class);
if (article != null) {
out.key("ad").value(article.isAdvertisement());
}
}
} catch (RepositoryException ex) {
log.error("could not query child for DPSResourceType", ex);
}
// if a user wants to delete an item from the tree, we must check if it is replicated
// thus, adding replication state information to the JSON result
try {
writeReplicationState(out, resource);
} catch (Exception e) {
throw new JSONException("Unable to append replication state", e);
}
out.endObject();
}
out.endArray();
}