/*
* Copyright (c) 2010, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.wso2.carbon.registry.jcr.version;
import org.wso2.carbon.registry.core.CollectionImpl;
import org.wso2.carbon.registry.core.exceptions.RegistryException;
import org.wso2.carbon.registry.jcr.RegistryNode;
import org.wso2.carbon.registry.jcr.RegistrySession;
import javax.jcr.*;
import javax.jcr.lock.LockException;
import javax.jcr.nodetype.ConstraintViolationException;
import javax.jcr.version.Version;
import javax.jcr.version.VersionException;
import javax.jcr.version.VersionHistory;
import javax.jcr.version.VersionManager;
import java.util.HashMap;
import java.util.Map;
public class RegistryVersionManager implements VersionManager {
private static long versionCounter = 0;
private Session session;
private Map<String, VersionHistory> versionHistories = new HashMap<String, VersionHistory>();
private String currentActivityNodePath = "";
private int configNodeCount = 0;
public RegistryVersionManager(Session session) {
this.session = session;
// loadActivityNodes();
}
private void loadActivityNodes() {
try {
if ((!(((RegistrySession) session).itemExists("/jcr:system")) && ((RegistrySession) session).itemExists("/jcr:system/jcr:activities"))) {
((RegistrySession) session).getRootNode().addNode("jcr:system").addNode("jcr:activities");
}
} catch (RepositoryException e) {
e.printStackTrace();
}
}
public Version checkin(String s) throws VersionException, UnsupportedRepositoryOperationException, InvalidItemStateException, LockException, RepositoryException {
Version version = null;
String latestVersionPath = "";
Value propVal = ((Node) session.getItem(s)).getProperty("jcr:checkedOut").getValue();
if ((propVal != null) && (propVal.getString().equals("true"))) {
((Node) session.getItem(s)).setProperty("jcr:checkedOut", "false");
((Node) session.getItem(s)).setProperty("jcr:isCheckedOut", "false");
try {
((RegistrySession) session).getUserRegistry().createVersion(s);
String[] regVerPaths = ((RegistrySession) session).getUserRegistry().getVersions(s);
latestVersionPath = regVerPaths[0]; //Here we assume that latest version path is given by the last element of tye version array
if (((RegistrySession) session).getUserRegistry().get(s) instanceof CollectionImpl) {
CollectionImpl tempColl = ((CollectionImpl) ((RegistrySession) session).getUserRegistry().get(s));
tempColl.getPropertyValues("wso2.registry.jcr.versions").add(latestVersionPath);
((RegistrySession) session).getUserRegistry().put(s, tempColl);
}
((CollectionImpl) ((RegistrySession) session).getUserRegistry().get(s)).getPropertyValues("wso2.registry.jcr.versions");
} catch (RegistryException e) {
e.printStackTrace();
}
version = new RegistryVersion(latestVersionPath, System.currentTimeMillis(), s, session);
if (versionHistories.get(s) != null) {
((RegistryVersionHistory) versionHistories.get(s)).getVersionList().add(version);
((RegistryVersion) version).setVersionHistory((RegistryVersionHistory) versionHistories.get(s));
} else {
RegistryVersionHistory vh = new RegistryVersionHistory(session);
vh.getVersionList().add(version);
((RegistryVersion) version).setVersionHistory(vh);
versionHistories.put(s, vh);
}
} else {
version = getBaseVersion(s);
}
return version;
}
public void checkout(String s) throws UnsupportedRepositoryOperationException, LockException, RepositoryException {
if ((((Node) session.getItem(s)).isNodeType("mix:simpleVersionable")) || ((((Node) session.getItem(s)).getParent().isNodeType("mix:simpleVersionable")))) {
((Node) session.getItem(s)).setProperty("jcr:checkedOut", "true"); // no need both.But as in JCR spec there are two properties to set
((Node) session.getItem(s)).setProperty("jcr:isCheckedOut", "true");
} else {
throw new UnsupportedRepositoryOperationException();
}
}
public Version checkpoint(String s) throws VersionException, UnsupportedRepositoryOperationException, InvalidItemStateException, LockException, RepositoryException {
checkout(s);
return checkin(s);
}
public boolean isCheckedOut(String s) throws RepositoryException {
boolean isCheckedOut = false;
if (!((Node) session.getItem(s)).isNodeType("mix:simpleVersionable")) {
isCheckedOut = true;
}
Value propVal = ((Node) session.getItem(s)).getProperty("jcr:checkedOut").getValue();
Value propVal1 = ((Node) session.getItem(s)).getProperty("jcr:isCheckedOut").getValue();
if ((propVal1 != null) && (propVal != null) && (propVal.getString().equals("true")) && (propVal1.getString().equals("true"))) {
isCheckedOut = true;
}
return isCheckedOut;
}
public VersionHistory getVersionHistory(String s) throws UnsupportedRepositoryOperationException, RepositoryException {
return versionHistories.get(s);
}
public Version getBaseVersion(String s) throws UnsupportedRepositoryOperationException, RepositoryException {
if (((RegistryVersionHistory) versionHistories.get(s) != null) &&
(((RegistryVersionHistory) versionHistories.get(s)).getVersionList().iterator().hasNext())) {
return (Version) ((RegistryVersionHistory) versionHistories.get(s)).getVersionList().iterator().next();
} else {
return null;
}
}
public void restore(Version[] versions, boolean b) throws ItemExistsException, UnsupportedRepositoryOperationException, VersionException, LockException, InvalidItemStateException, RepositoryException {
//TODO
}
public void restore(String s, String s1, boolean b) throws VersionException, ItemExistsException, UnsupportedRepositoryOperationException, LockException, InvalidItemStateException, RepositoryException {
((Node) session.getItem(s)).setProperty("jcr:isCheckedOut", "false");
}
public void restore(Version version, boolean b) throws VersionException, ItemExistsException, InvalidItemStateException, UnsupportedRepositoryOperationException, LockException, RepositoryException {
try {
if (version != null) {
((RegistrySession) session).getUserRegistry().restoreVersion(version.getName());
version.getFrozenNode().setProperty("jcr:isCheckedOut", "false");
}
} catch (RegistryException e) {
e.printStackTrace();
}
}
public void restore(String s, Version version, boolean b) throws PathNotFoundException, ItemExistsException, VersionException, ConstraintViolationException, UnsupportedRepositoryOperationException, LockException, InvalidItemStateException, RepositoryException {
try {
if (version != null) {
((RegistryVersionHistory) versionHistories.get(s)).getVersionList().add(version);
((Node) session.getItem(s)).setProperty("jcr:isCheckedOut", "false");
((RegistrySession) session).getUserRegistry().restoreVersion(version.getName());
}
} catch (RegistryException e) {
e.printStackTrace();
}
}
public void restoreByLabel(String s, String s1, boolean b) throws VersionException, ItemExistsException, UnsupportedRepositoryOperationException, LockException, InvalidItemStateException, RepositoryException {
String verPAth = ((Node) ((RegistrySession) session).getItem("/jcr:system/jcr:gregVersionLabels")).getProperty(s1).getString();
try {
((RegistrySession) session).getUserRegistry().restoreVersion(verPAth);
} catch (RegistryException e) {
e.printStackTrace();
}
}
// TODO :All merging stuff
public NodeIterator merge(String s, String s1, boolean b) throws NoSuchWorkspaceException, AccessDeniedException, MergeException, LockException, InvalidItemStateException, RepositoryException {
return null;
}
public NodeIterator merge(String s, String s1, boolean b, boolean b1) throws NoSuchWorkspaceException, AccessDeniedException, MergeException, LockException, InvalidItemStateException, RepositoryException {
return null;
}
public void doneMerge(String s, Version version) throws VersionException, InvalidItemStateException, UnsupportedRepositoryOperationException, RepositoryException {
}
public void cancelMerge(String s, Version version) throws VersionException, InvalidItemStateException, UnsupportedRepositoryOperationException, RepositoryException {
}
public Node createConfiguration(String s) throws UnsupportedRepositoryOperationException, RepositoryException {
/*
Calling createConfiguration on the node N at absPath creates, in the configuration storage, a new
nt:configuration node whose root is N. A reference to N is recorded in the jcr:root
property of the new configuration, and a reference to the new configuration
is recorded in the jcr:configuration property of N
*/
String configNodeName = "jcr:configNode" + configNodeCount++;
((RegistryNode) session.getItem(s)).addNode(configNodeName, "nt:configuration").setProperty("jcr:root", s);
((RegistryNode) session.getItem(s)).setProperty("jcr:configuration", s + "/" + configNodeName);
return (RegistryNode) session.getItem(s + "/" + configNodeName);
}
public Node setActivity(Node node) throws UnsupportedRepositoryOperationException, RepositoryException {
RegistryNode acNode = null;
if (node == null) {
currentActivityNodePath = "";
if (((RegistryNode) session.getItem("/jcr:system/jcr:activities")).getNodes().hasNext()) {
acNode = (RegistryNode) ((RegistryNode) session.getItem("/jcr:system/jcr:activities")).getNodes().next();
}
} else {
currentActivityNodePath = node.getPath();
acNode = (RegistryNode) createActivity(node.getPath());
}
return acNode;
}
public Node getActivity() throws UnsupportedRepositoryOperationException, RepositoryException {
return (Node) ((RegistrySession) session).getItem(currentActivityNodePath);
}
public Node createActivity(String s) throws UnsupportedRepositoryOperationException, RepositoryException {
currentActivityNodePath = "/jcr:system/jcr:activities" + s;
return ((RegistryNode) ((RegistrySession) session).getItem("/jcr:system/jcr:activities")).addNode(s, "nt:activity");
}
public void removeActivity(Node node) throws UnsupportedRepositoryOperationException, VersionException, RepositoryException {
((RegistrySession) session).removeItem(node.getPath());
}
public NodeIterator merge(Node node) throws VersionException, AccessDeniedException, MergeException, LockException, InvalidItemStateException, RepositoryException {
return null;
}
}