/**
* 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 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);
}
}
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();
}
/** Write a single property */
protected void writeProperty(JSONWriter w, Property p)
throws ValueFormatException, RepositoryException, JSONException {
// special handling for binaries: we dump the length and not the length
if (p.getType() == PropertyType.BINARY) {
// TODO for now we mark binary properties with an initial colon in
// their name
// (colon is not allowed as a JCR property name)
// in the name, and the value should be the size of the binary data
w.key(":" + p.getName());
if (!p.getDefinition().isMultiple()) {
w.value(p.getLength());
} else {
final long[] sizes = p.getLengths();
w.array();
for (int i = 0; i < sizes.length; i++) {
w.value(sizes[i]);
}
w.endArray();
}
return;
}
w.key(p.getName());
if (!p.getDefinition().isMultiple()) {
dumpValue(w, p.getValue());
} else {
w.array();
for (Value v : p.getValues()) {
dumpValue(w, v);
}
w.endArray();
}
}
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();
}
}
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 extractAttachment(
final Writer ioWriter, final JSONWriter writer, final Resource node)
throws JSONException, UnsupportedEncodingException {
Resource contentNode = node.getChild("jcr:content");
if (contentNode == null) {
writer.key(ContentTypeDefinitions.LABEL_ERROR);
writer.value(
"provided resource was not an attachment - no content node beneath " + node.getPath());
return;
}
ValueMap content = contentNode.adaptTo(ValueMap.class);
if (!content.containsKey("jcr:mimeType") || !content.containsKey("jcr:data")) {
writer.key(ContentTypeDefinitions.LABEL_ERROR);
writer.value(
"provided resource was not an attachment - content node contained no attachment data under "
+ node.getPath());
return;
}
writer.key("filename");
writer.value(URLEncoder.encode(node.getName(), "UTF-8"));
writer.key("jcr:mimeType");
writer.value(content.get("jcr:mimeType"));
try {
ioWriter.write(",\"jcr:data\":\"");
final InputStream data = (InputStream) content.get("jcr:data");
byte[] byteData = new byte[DATA_ENCODING_CHUNK_SIZE];
int read = 0;
while (read != -1) {
read = data.read(byteData);
if (read > 0 && read < DATA_ENCODING_CHUNK_SIZE) {
// make a right-size container for the byte data actually read
byte[] byteArray = new byte[read];
System.arraycopy(byteData, 0, byteArray, 0, read);
byte[] encodedBytes = Base64.encodeBase64(byteArray);
ioWriter.write(new String(encodedBytes));
} else if (read == DATA_ENCODING_CHUNK_SIZE) {
byte[] encodedBytes = Base64.encodeBase64(byteData);
ioWriter.write(new String(encodedBytes));
}
}
ioWriter.write("\"");
} catch (IOException e) {
writer.key(ContentTypeDefinitions.LABEL_ERROR);
writer.value(
"IOException while getting attachment at " + node.getPath() + ": " + e.getMessage());
}
}
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();
}
}
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 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 the given value to the JSON writer. currently the following conversions are done:
*
* <table>
* <tr>
* <th>JSR Property Type</th>
* <th>JSON Value Type</th>
* </tr>
* <tr>
* <td>BINARY</td>
* <td>always 0 as long</td>
* </tr>
* <tr>
* <td>DATE</td>
* <td>converted date string as defined by ECMA</td>
* </tr>
* <tr>
* <td>BOOLEAN</td>
* <td>boolean</td>
* </tr>
* <tr>
* <td>LONG</td>
* <td>long</td>
* </tr>
* <tr>
* <td>DOUBLE</td>
* <td>double</td>
* </tr>
* <tr>
* <td><i>all other</li>
* </td>
* <td>string</td>
* </tr>
* </table>
*
* <sup>1</sup> Currently not implemented and uses 0 as default.
*
* @param w json writer
* @param v value to dump
*/
protected void dumpValue(JSONWriter w, Value v)
throws ValueFormatException, IllegalStateException, RepositoryException, JSONException {
switch (v.getType()) {
case PropertyType.BINARY:
w.value(0);
break;
case PropertyType.DATE:
w.value(format(v.getDate()));
break;
case PropertyType.BOOLEAN:
w.value(v.getBoolean());
break;
case PropertyType.LONG:
w.value(v.getLong());
break;
case PropertyType.DOUBLE:
w.value(v.getDouble());
break;
default:
w.value(v.getString());
}
}
public static void writeNodeContentsToWriter(JSONWriter write, Node node)
throws RepositoryException, JSONException {
// Since removal of bigstore we add in jcr:path and jcr:name
write.key("jcr:path");
write.value(PathUtils.translateAuthorizablePath(node.getPath()));
write.key("jcr:name");
write.value(node.getName());
PropertyIterator properties = node.getProperties();
while (properties.hasNext()) {
Property prop = properties.nextProperty();
String name = prop.getName();
write.key(name);
PropertyDefinition propertyDefinition = prop.getDefinition();
int propertyType = prop.getType();
if (PropertyType.BINARY == propertyType) {
if (propertyDefinition.isMultiple()) {
write.array();
for (long l : prop.getLengths()) {
write.value("binary-length:" + String.valueOf(l));
}
write.endArray();
} else {
write.value("binary-length:" + String.valueOf(prop.getLength()));
}
} else {
if (propertyDefinition.isMultiple()) {
Value[] values = prop.getValues();
write.array();
for (Value value : values) {
Object ovalue = stringValue(value);
if (isUserPath(name, ovalue)) {
write.value(PathUtils.translateAuthorizablePath(ovalue));
} else {
write.value(ovalue);
}
}
write.endArray();
} else {
Object value = stringValue(prop.getValue());
if (isUserPath(name, value)) {
write.value(PathUtils.translateAuthorizablePath(value));
} else {
write.value(value);
}
}
}
}
}
private void writeCommentCountProperty(JSONWriter write, Session session, Content contentResult)
throws StorageClientException, JSONException, AccessDeniedException {
ContentManager contentManager = session.getContentManager();
Content comments = contentManager.get(contentResult.getPath() + "/" + "comments");
long commentCount = 0;
if (comments != null) {
for (@SuppressWarnings("unused") Content comment : comments.listChildren()) {
commentCount++;
}
}
write.key("commentCount");
write.value(commentCount);
}
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();
}
}
/**
* {@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();
}
/**
* 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();
}
}
private void writeCanManageProperty(
SlingHttpServletRequest request, JSONWriter write, Session session, Content contentResult)
throws StorageClientException, JSONException, AccessDeniedException {
write.key("sakai:canmanage");
Authorizable thisUser =
session.getAuthorizableManager().findAuthorizable(request.getRemoteUser());
Collection<String> principals = new ArrayList<String>();
principals.addAll(Arrays.asList(thisUser.getPrincipals()));
principals.add(request.getRemoteUser());
boolean canManage = false;
for (String principal : principals) {
if (Arrays.asList(
StorageClientUtils.nonNullStringArray(
(String[]) contentResult.getProperty("sakai:pooled-content-manager")))
.contains(principal)) {
canManage = true;
}
}
write.value(canManage);
}
/**
* Writes commentCount of content
*
* @param node
* @param session
* @param write
* @throws RepositoryException
* @throws JSONException
*/
public static void writeCommentCountProperty(
Content content,
org.sakaiproject.nakamura.api.lite.Session session,
JSONWriter writer,
Repository repository)
throws StorageClientException, JSONException {
int commentCount = 0;
String COMMENTCOUNT = "commentCount";
if (content.hasProperty(COMMENTCOUNT)) {
commentCount = (Integer) content.getProperty(COMMENTCOUNT);
} else {
// no commentCount property on Content, then evaluate count and add property
Content comments = null;
org.sakaiproject.nakamura.api.lite.Session adminSession = null;
try {
comments = session.getContentManager().get(content.getPath() + "/comments");
if (comments != null) {
commentCount = Iterables.size(comments.listChildPaths());
}
content.setProperty(COMMENTCOUNT, commentCount);
// save property
adminSession = repository.loginAdministrative();
ContentManager adminContentManager = adminSession.getContentManager();
adminContentManager.update(content);
} catch (org.sakaiproject.nakamura.api.lite.accesscontrol.AccessDeniedException e) {
log.error(e.getMessage(), e);
} finally {
if (adminSession != null) {
try {
adminSession.logout();
} catch (Exception e) {
log.error("Could not logout administrative session.");
}
}
}
}
writer.key(COMMENTCOUNT);
writer.value(commentCount);
}
/**
* 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();
}
@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response)
throws ServletException, IOException {
try {
final ResourceResolver resolver = request.getResourceResolver();
final String vanityPath = request.getParameter("vanityPath");
final String pagePath = request.getParameter("pagePath");
log.debug(
"vanity path parameter passed is {}; page path parameter passed is {}",
vanityPath,
pagePath);
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");
JSONWriter jsonWriter = new JSONWriter(response.getWriter());
jsonWriter.array();
if (StringUtils.isNotBlank(vanityPath)) {
String xpath =
"//element(*)[" + NameConstants.PN_SLING_VANITY_PATH + "='" + vanityPath + "']";
@SuppressWarnings("deprecation")
Iterator<Resource> resources = resolver.findResources(xpath, Query.XPATH);
while (resources.hasNext()) {
Resource resource = resources.next();
String path = resource.getPath();
if (path.startsWith("/content") && !path.equals(pagePath)) {
jsonWriter.value(path);
}
}
}
jsonWriter.endArray();
} catch (JSONException e) {
throw new ServletException("Unable to generate JSON result", e);
}
}
public void write(JSONWriter writer) throws JSONException {
writer.value(this);
}
/**
* {@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.");
}
}
public static void extractTopic(
final JSONWriter writer,
final Post post,
final ResourceResolver resolver,
final String resourceType,
final String childResourceType,
final Writer responseWriter)
throws JSONException, IOException {
final ValueMap vm = post.getProperties();
final JSONArray timestampFields = new JSONArray();
for (final Map.Entry<String, Object> prop : vm.entrySet()) {
final Object value = prop.getValue();
if (value instanceof String[]) {
final JSONArray list = new JSONArray();
for (String v : (String[]) value) {
list.put(v);
}
writer.key(prop.getKey());
writer.value(list);
} else if (value instanceof GregorianCalendar) {
timestampFields.put(prop.getKey());
writer.key(prop.getKey());
writer.value(((Calendar) value).getTimeInMillis());
} else if (prop.getKey().equals("sling:resourceType")) {
writer.key(prop.getKey());
writer.value(resourceType);
} else if (prop.getKey().equals("sentiment")) {
writer.key(prop.getKey());
// 1 = 1, 2 = 3, 3 = 5, 4 = 8, 5 = 10
short shortValue = Short.parseShort(value.toString());
switch (shortValue) {
case 1:
writer.value(1);
break;
case 2:
writer.value(3);
break;
case 3:
writer.value(5);
break;
case 4:
writer.value(8);
break;
case 5:
writer.value(10);
break;
default:
writer.value(value);
}
} else {
writer.key(prop.getKey());
try {
writer.value(URLEncoder.encode(prop.getValue().toString(), "UTF-8"));
} catch (final UnsupportedEncodingException e) {
throw new JSONException(
"Unsupported encoding (UTF-8) for resource at " + post.getPath(), e);
}
}
}
if (timestampFields.length() > 0) {
writer.key(ContentTypeDefinitions.LABEL_TIMESTAMP_FIELDS);
writer.value(timestampFields);
}
final Resource thisResource = resolver.getResource(post.getPath());
final Resource attachments = thisResource.getChild("attachments");
if (attachments != null) {
writer.key(ContentTypeDefinitions.LABEL_ATTACHMENTS);
final JSONWriter attachmentsWriter = writer.array();
for (final Resource attachment : attachments.getChildren()) {
UGCExportHelper.extractAttachment(responseWriter, attachmentsWriter.object(), attachment);
attachmentsWriter.endObject();
}
writer.endArray();
}
final Iterable<Resource> children = thisResource.getChildren();
for (final Resource child : children) {
if (child.isResourceType("social/tally/components/hbs/voting")
|| child.isResourceType("social/tally/components/voting")) {
writer.key(ContentTypeDefinitions.LABEL_TALLY);
final JSONWriter voteObjects = writer.array();
UGCExportHelper.extractTally(voteObjects, child, "Voting");
writer.endArray();
} else if (child.getName().equals("translation")) {
extractTranslation(writer, child);
}
}
final Iterator<Post> posts = post.getPosts();
if (posts.hasNext()) {
writer.key(ContentTypeDefinitions.LABEL_REPLIES);
final JSONWriter replyWriter = writer.object();
while (posts.hasNext()) {
Post childPost = posts.next();
replyWriter.key(childPost.getId());
extractTopic(
replyWriter.object(),
childPost,
resolver,
childResourceType,
childResourceType,
responseWriter);
replyWriter.endObject();
}
writer.endObject();
}
}
public static void extractJournalEntry(
final JSONWriter entryObject, final JournalEntry entry, final Writer rawWriter)
throws JSONException, IOException {
final Resource thisResource = entry.getTextComment().getResource();
final ValueMap vm = thisResource.adaptTo(ValueMap.class);
final JSONArray timestampFields = new JSONArray();
// make sure we only migrate the fields we want
final Map<String, Boolean> fieldsToMigrate = new HashMap<String, Boolean>();
fieldsToMigrate.put("userIdentifier", true);
fieldsToMigrate.put("authorizableId", true);
fieldsToMigrate.put("published", true);
fieldsToMigrate.put("jcr:description", true);
fieldsToMigrate.put("jcr:title", true);
fieldsToMigrate.put("negative", true);
fieldsToMigrate.put("positive", true);
fieldsToMigrate.put("sentiment", true);
for (final Map.Entry<String, Object> prop : vm.entrySet()) {
if (!fieldsToMigrate.containsKey(prop.getKey())) {
continue;
}
final Object value = prop.getValue();
if (prop.getKey().equals("published") && value instanceof GregorianCalendar) {
timestampFields.put("added");
entryObject.key("added");
entryObject.value(((Calendar) value).getTimeInMillis());
} else {
entryObject.key(prop.getKey());
try {
entryObject.value(URLEncoder.encode(prop.getValue().toString(), "UTF-8"));
} catch (final UnsupportedEncodingException e) {
throw new JSONException(
"Unsupported encoding (UTF-8) for resource at " + thisResource.getPath(), e);
}
}
}
// resource type has changed, so ignore the current one and force the new one
entryObject.key("sling:resourceType");
entryObject.value("social/journal/components/hbs/entry_topic");
if (timestampFields.length() > 0) {
entryObject.key(ContentTypeDefinitions.LABEL_TIMESTAMP_FIELDS);
entryObject.value(timestampFields);
}
final Resource translationResource = thisResource.getChild("translation");
if (null != translationResource) {
extractTranslation(entryObject, translationResource);
}
if (entry.hasAttachments()) {
entryObject.key(ContentTypeDefinitions.LABEL_ATTACHMENTS);
JSONWriter attachmentsArray = entryObject.array();
List<Resource> attachmentList = entry.getAttachments();
for (final Resource attachment : attachmentList) {
extractAttachment(rawWriter, attachmentsArray.object(), attachment);
attachmentsArray.endObject();
}
entryObject.endArray();
}
if (entry.hasComments()) {
final Iterator<Comment> posts = entry.getComments();
entryObject.key(ContentTypeDefinitions.LABEL_REPLIES);
final JSONWriter replyWriter = entryObject.object();
while (posts.hasNext()) {
final Comment childPost = posts.next();
replyWriter.key(childPost.getId());
extractComment(
replyWriter.object(), childPost, entry.getResource().getResourceResolver(), rawWriter);
replyWriter.endObject();
}
entryObject.endObject();
}
}
public static void extractProperties(
final JSONWriter object,
final Map<String, Object> properties,
final Map<String, String> renamedProperties,
final String resourceType)
throws JSONException {
final JSONArray timestampFields = new JSONArray();
boolean setResourceType = false;
for (Map.Entry<String, Object> prop : properties.entrySet()) {
Object value = prop.getValue();
String key;
if (null != renamedProperties && renamedProperties.containsKey(prop.getKey())) {
key = renamedProperties.get(prop.getKey());
if (null == key) {
continue; // we're excluding this property from the export
}
} else {
key = prop.getKey();
}
if (null != resourceType && key.equals(JcrResourceConstants.SLING_RESOURCE_TYPE_PROPERTY)) {
value = resourceType;
setResourceType = true;
}
if (value instanceof String[]) {
final JSONArray list = new JSONArray();
for (String v : (String[]) value) {
try {
list.put(URLEncoder.encode(v, "UTF-8"));
} catch (final UnsupportedEncodingException e) {
throw new JSONException(
"String value cannot be encoded as UTF-8 for JSON transmission", e);
}
}
object.key(key);
object.value(list);
} else if (value instanceof GregorianCalendar) {
timestampFields.put(key);
object.key(key);
object.value(((Calendar) value).getTimeInMillis());
} else if (value instanceof InputStream) {
object.key(ContentTypeDefinitions.LABEL_ENCODED_DATA_FIELDNAME);
object.value(key);
object.key(ContentTypeDefinitions.LABEL_ENCODED_DATA);
try {
final InputStream data = (InputStream) value;
byte[] byteData = new byte[DATA_ENCODING_CHUNK_SIZE];
int read = 0;
final StringBuilder stringBuilder = new StringBuilder();
while (read != -1) {
read = data.read(byteData);
if (read > 0 && read < DATA_ENCODING_CHUNK_SIZE) {
// make a right-size container for the byte data actually read
byte[] byteArray = new byte[read];
System.arraycopy(byteData, 0, byteArray, 0, read);
byte[] encodedBytes = Base64.encodeBase64(byteArray);
stringBuilder.append(new String(encodedBytes));
} else if (read == DATA_ENCODING_CHUNK_SIZE) {
byte[] encodedBytes = Base64.encodeBase64(byteData);
stringBuilder.append(new String(encodedBytes));
}
}
object.value(stringBuilder.toString());
} catch (IOException e) {
object.value(
""); // if we error out on the first read attempt, we need a placeholder value still
object.key(ContentTypeDefinitions.LABEL_ERROR);
object.value("IOException while getting attachment: " + e.getMessage());
}
} else {
object.key(key);
try {
object.value(URLEncoder.encode(value.toString(), "UTF-8"));
} catch (final UnsupportedEncodingException e) {
throw new JSONException(
"String value cannot be encoded as UTF-8 for JSON transmission", e);
}
}
}
if (null != resourceType
&& !setResourceType) { // make sure this gets included if it's been specified
object.key(JcrResourceConstants.SLING_RESOURCE_TYPE_PROPERTY);
object.value(resourceType);
}
if (timestampFields.length() > 0) {
object.key(ContentTypeDefinitions.LABEL_TIMESTAMP_FIELDS);
object.value(timestampFields);
}
}