com.day.cq.commons.DiffInfo Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aem-sdk-api Show documentation
Show all versions of aem-sdk-api Show documentation
The Adobe Experience Manager SDK
/*
* Copyright 1997-2009 Day Management AG
* Barfuesserplatz 6, 4001 Basel, Switzerland
* All Rights Reserved.
*
* This software is the confidential and proprietary information of
* Day Management AG, ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Day.
*/
package com.day.cq.commons;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.version.*;
import javax.jcr.version.Version;
import org.apache.commons.lang.time.FastDateFormat;
import org.apache.sling.api.resource.Resource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.day.cq.commons.jcr.JcrConstants;
/**
* The DiffInfo can be used by components
* to display a diff to a previous version.
* A component has access to the diff information by
* calling {@link Resource#adaptTo(Class)} with this
* class as the argument.
*
* @since 5.2
*/
public class DiffInfo {
public static final FastDateFormat DATE_DEFAULT = FastDateFormat.getInstance("dd.MM.yyyy HH:mm:ss");
/**
* default logger
*/
private static final Logger log = LoggerFactory.getLogger(DiffInfo.class);
/**
* The general information about the diff
*/
public enum TYPE {
/**
* this resource is new and not contained in the old version
*/
ADDED,
/**
* this resource has been removed and is only in the old version
*/
REMOVED,
/**
* this resource is in both versions but at different locations
*/
MOVED,
/**
* resource is in both versions at the same location
*/
SAME
}
/**
* The content to diff.
*/
private final Resource content;
/**
* The type information
*/
private final TYPE type;
public DiffInfo(final Resource c, final TYPE l) {
this.content = c;
this.type = l;
}
/**
* Return the content to diff.
*
* @return The content or null
*/
public Resource getContent() {
return this.content;
}
/**
* Return the type information.
*
* @return The type information.
*/
public TYPE getType() {
return this.type;
}
/**
* Helper method to generate the diff output.
*
* @param service The diff service.
* @param current The current text (right).
* @param oldText The old text (left).
* @param isRichText Is this rich text?
* @return The complete output or null.
*/
public String getDiffOutput(DiffService service, String current,
String oldText, boolean isRichText) {
if (service != null) {
if (getType() == DiffInfo.TYPE.ADDED) {
return service.diff(current, null, isRichText);
} else if (getType() == DiffInfo.TYPE.REMOVED) {
return service.diff(null, oldText, isRichText);
}
return service.diff(current, oldText, isRichText);
}
return null;
}
/**
* Helper method that returns the versioned counterpart of the given resource
* with the specified version label. The label can be a version name, a
* version label or a version date.
*
* @param res the resource
* @param versionLabel the version specifier
* @return the versioned resource or null
*/
public static Resource getVersionedResource(Resource res, String versionLabel) {
Node currentNode = res.adaptTo(Node.class);
if (currentNode == null) {
return null;
}
try {
Node versionNode = getVersionedNode(currentNode, versionLabel);
if (versionNode != null) {
return res.getResourceResolver().getResource(versionNode.getPath());
}
} catch (RepositoryException e) {
log.error("Error while trying to get versioned node for path " + res.getPath() + ", version " + versionLabel, e);
}
return null;
}
/**
* Get the versioned node for a node.
*
* @param node The current node.
* @param versionTag The version tag or label
* @return The versioned node or null
* @throws RepositoryException if an error occurs
*/
private static Node getVersionedNode(Node node, String versionTag)
throws RepositoryException {
String path = node.getPath();
while (node != null && !node.isNodeType(JcrConstants.MIX_VERSIONABLE)) {
if (node.getDepth() > 0) {
node = node.getParent();
} else {
node = null;
}
}
if (node == null) {
log.debug("getVersionedNode: No versionable node exists at path '{}'", path);
return null;
}
// we have the versionable node, let's get the version
//check if we can parse the version info as a date
Node versionNode = null;
try {
SimpleDateFormat sdf = new SimpleDateFormat(DATE_DEFAULT.getPattern());
Date d = sdf.parse(versionTag);
Calendar versionDate = Calendar.getInstance();
versionDate.setTime(d);
versionNode = getVersion(node, versionDate);
} catch (ParseException e) {
// we ignore this
}
if (versionNode == null) {
try {
versionNode = node.getVersionHistory().getVersion(versionTag);
} catch (VersionException ve) {
try {
versionNode = node.getVersionHistory().getVersionByLabel(versionTag);
} catch (VersionException ve2) {
// we just ignore this
}
}
}
if (versionNode == null) {
log.debug("getVersionedNode: Version '{}' not found for path '{}'", versionTag, path);
return null;
}
// try to get child
if (!node.getPath().equals(path)) {
Session session = node.getSession();
// build complete path:
String childPath = versionNode.getPath() + "/" + JcrConstants.JCR_FROZENNODE + path.substring(node.getPath().length());
if (!session.itemExists(childPath)) {
log.debug("getVersionedNode: Version '{}' not found for path '{}'", versionTag, path);
return null;
}
versionNode = (Node) session.getItem(childPath);
} else {
if (versionNode.hasNode(JcrConstants.JCR_FROZENNODE)) {
versionNode = versionNode.getNode(JcrConstants.JCR_FROZENNODE);
} else {
log.debug("getVersionedNode: Frozen node not found in version '{}' for path '{}'", versionTag, path);
return null;
}
}
return versionNode;
}
/**
* Get the versioned node closest to the provided date.
* @param versionedNode the versionable node
* @param cal the date
* @return the versioned node or null
* @throws RepositoryException if an error occurs
*/
private static Node getVersion(Node versionedNode, Calendar cal)
throws RepositoryException {
ArrayList revisions = new ArrayList();
VersionIterator iter = versionedNode.getVersionHistory().getAllVersions();
while (iter.hasNext()) {
revisions.add(iter.nextVersion());
}
// sort revisions by creation date in descending order
Collections.sort(revisions, new Comparator() {
public int compare(Version r1, Version r2) {
try {
return r2.getCreated().compareTo(r1.getCreated());
} catch (RepositoryException re) {
// we ignore this - no good way to handle it.
return 0;
}
}
});
for (Version v : revisions) {
if (v.getCreated().compareTo(cal) <= 0) {
return v;
}
}
return null;
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy