public void save(final int operationType)
throws AccessDeniedException, ItemExistsException, ConstraintViolationException,
InvalidItemStateException, VersionException, LockException, NoSuchNodeTypeException,
RepositoryException {
if (!isSystem() && getLocale() != null) {
for (JCRNodeWrapper node : newNodes.values()) {
for (String s : node.getNodeTypes()) {
ExtendedPropertyDefinition[] propDefs =
NodeTypeRegistry.getInstance().getNodeType(s).getPropertyDefinitions();
for (ExtendedPropertyDefinition propDef : propDefs) {
if (propDef.isMandatory()
&& propDef.getRequiredType() != PropertyType.WEAKREFERENCE
&& propDef.getRequiredType() != PropertyType.REFERENCE
&& !propDef.isProtected()
&& !node.hasProperty(propDef.getName())) {
throw new ConstraintViolationException("Mandatory field : " + propDef.getName());
}
}
}
}
}
newNodes.clear();
JCRObservationManager.doWorkspaceWriteCall(
this,
operationType,
new JCRCallback<Object>() {
public Object doInJCR(JCRSessionWrapper thisSession) throws RepositoryException {
for (Session session : sessions.values()) {
session.save();
}
return null;
}
});
}
void unregisterNewNode(JCRNodeWrapper node) {
if (!newNodes.isEmpty()) {
newNodes.remove(node.getPath());
try {
if (node.hasNodes()) {
NodeIterator it = node.getNodes();
while (it.hasNext()) {
unregisterNewNode((JCRNodeWrapper) it.next());
}
}
} catch (RepositoryException e) {
logger.warn("Error unregistering new nodes", e);
}
}
}
public void removeItem(String absPath)
throws VersionException, LockException, ConstraintViolationException, AccessDeniedException,
RepositoryException {
JCRItemWrapper item = getItem(absPath);
boolean flushNeeded = false;
if (item.isNode()) {
JCRNodeWrapper node = (JCRNodeWrapper) item;
unregisterNewNode(node);
if (node.hasNodes()) {
flushNeeded = true;
}
}
item.remove();
if (flushNeeded) {
flushCaches();
} else {
removeFromCache(item);
}
}
public void importXML(
String path,
InputStream inputStream,
int uuidBehavior,
int rootBehavior,
Map<String, String> replacements)
throws IOException, InvalidSerializedDataException, RepositoryException {
JCRNodeWrapper node = getNode(path);
try {
if (!node.isCheckedOut()) {
checkout(node);
}
} catch (UnsupportedRepositoryOperationException ex) {
// versioning not supported
}
DocumentViewImportHandler documentViewImportHandler = new DocumentViewImportHandler(this, path);
documentViewImportHandler.setRootBehavior(rootBehavior);
documentViewImportHandler.setUuidBehavior(uuidBehavior);
documentViewImportHandler.setReplacements(replacements);
try {
SAXParserFactory factory;
factory = new SAXParserFactoryImpl();
factory.setNamespaceAware(true);
factory.setValidating(false);
factory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
SAXParser parser = factory.newSAXParser();
parser.parse(inputStream, documentViewImportHandler);
} catch (SAXParseException e) {
logger.error("Cannot import - File is not a valid XML", e);
} catch (Exception e) {
logger.error("Cannot import", e);
}
}
private JCRNodeWrapper dereference(JCRNodeWrapper parent, String refPath)
throws RepositoryException {
JCRStoreProvider provider = parent.getProvider();
JCRNodeWrapper wrapper;
Node referencedNode = parent.getRealNode().getProperty("j:node").getNode();
String fullPath = parent.getPath() + DEREF_SEPARATOR + refPath;
if (parent.getPath().startsWith(referencedNode.getPath())) {
throw new PathNotFoundException(fullPath);
}
String refRootName = StringUtils.substringBefore(refPath, "/");
if (!referencedNode.getName().equals(refRootName)) {
throw new PathNotFoundException(fullPath);
}
refPath = StringUtils.substringAfter(refPath, "/");
if (refPath.equals("")) {
wrapper = provider.getNodeWrapper(referencedNode, fullPath, parent, this);
} else {
Node node = referencedNode.getNode(refPath);
wrapper = provider.getNodeWrapper(node, fullPath, null, this);
}
sessionCacheByPath.put(fullPath, wrapper);
return wrapper;
}
void registerNewNode(JCRNodeWrapper node) {
newNodes.put(node.getPath(), node);
}
public JCRItemWrapper getItem(String path, final boolean checkVersion)
throws PathNotFoundException, RepositoryException {
if (sessionCacheByPath.containsKey(path)) {
return sessionCacheByPath.get(path);
}
if (path.contains(DEREF_SEPARATOR)) {
JCRNodeWrapper parent =
(JCRNodeWrapper)
getItem(StringUtils.substringBeforeLast(path, DEREF_SEPARATOR), checkVersion);
return dereference(parent, StringUtils.substringAfterLast(path, DEREF_SEPARATOR));
}
Map<String, JCRStoreProvider> dynamicMountPoints = sessionFactory.getDynamicMountPoints();
for (Map.Entry<String, JCRStoreProvider> mp : dynamicMountPoints.entrySet()) {
if (path.startsWith(mp.getKey() + "/")) {
String localPath = path.substring(mp.getKey().length());
JCRStoreProvider provider = mp.getValue();
Item item = getProviderSession(provider).getItem(provider.getRelativeRoot() + localPath);
if (item.isNode()) {
return provider.getNodeWrapper((Node) item, localPath, null, this);
} else {
return provider.getPropertyWrapper((Property) item, this);
}
}
}
Map<String, JCRStoreProvider> mountPoints = sessionFactory.getMountPoints();
for (Map.Entry<String, JCRStoreProvider> mp : mountPoints.entrySet()) {
String key = mp.getKey();
if (key.equals("/") || path.equals(key) || path.startsWith(key + "/")) {
String localPath = path;
if (!key.equals("/")) {
localPath = localPath.substring(key.length());
}
JCRStoreProvider provider = mp.getValue();
if (localPath.equals("")) {
localPath = "/";
}
// Item item = getProviderSession(provider).getItem(localPath);
Session session = getProviderSession(provider);
if (session instanceof JahiaSessionImpl
&& getUser() != null
&& sessionFactory.getCurrentAliasedUser() != null
&& sessionFactory.getCurrentAliasedUser().equals(getUser())) {
((JahiaSessionImpl) session).toggleThisSessionAsAliased();
}
Item item = session.getItem(provider.getRelativeRoot() + localPath);
if (item.isNode()) {
final Node node = (Node) item;
JCRNodeWrapper wrapper = provider.getNodeWrapper(node, localPath, null, this);
if (getUser() != null
&& sessionFactory.getCurrentAliasedUser() != null
&& !sessionFactory.getCurrentAliasedUser().equals(getUser())) {
final JCRNodeWrapper finalWrapper = wrapper;
JCRTemplate.getInstance()
.doExecuteWithUserSession(
sessionFactory.getCurrentAliasedUser().getUsername(),
getWorkspace().getName(),
getLocale(),
new JCRCallback<Object>() {
public Object doInJCR(JCRSessionWrapper session) throws RepositoryException {
return session.getNodeByUUID(finalWrapper.getIdentifier(), checkVersion);
}
});
}
if (checkVersion
&& (versionDate != null || versionLabel != null)
&& node.isNodeType("mix:versionable")) {
wrapper = getFrozenVersionAsRegular(node, provider);
}
sessionCacheByPath.put(path, wrapper);
sessionCacheByIdentifier.put(wrapper.getIdentifier(), wrapper);
return wrapper;
} else {
return provider.getPropertyWrapper((Property) item, this);
}
}
}
throw new PathNotFoundException(path);
}
public JCRNodeWrapper getNodeByUUID(final String uuid, final boolean checkVersion)
throws ItemNotFoundException, RepositoryException {
if (sessionCacheByIdentifier.containsKey(uuid)) {
return sessionCacheByIdentifier.get(uuid);
}
RepositoryException originalEx = null;
for (JCRStoreProvider provider : sessionFactory.getProviderList()) {
if (!provider.isInitialized()) {
logger.debug(
"Provider "
+ provider.getKey()
+ " / "
+ provider.getClass().getName()
+ " is not yet initialized, skipping...");
continue;
}
if (provider instanceof JackrabbitStoreProvider && JCRContentUtils.isNotJcrUuid(uuid)) {
// not a valid UUID, probably a VFS node
continue;
}
try {
Session session = getProviderSession(provider);
if (session instanceof JahiaSessionImpl
&& getUser() != null
&& sessionFactory.getCurrentAliasedUser() != null
&& sessionFactory.getCurrentAliasedUser().equals(getUser())) {
((JahiaSessionImpl) session).toggleThisSessionAsAliased();
}
Node n = session.getNodeByIdentifier(uuid);
JCRNodeWrapper wrapper = provider.getNodeWrapper(n, this);
if (getUser() != null
&& sessionFactory.getCurrentAliasedUser() != null
&& !sessionFactory.getCurrentAliasedUser().equals(getUser())) {
JCRTemplate.getInstance()
.doExecuteWithUserSession(
sessionFactory.getCurrentAliasedUser().getUsername(),
session.getWorkspace().getName(),
getLocale(),
new JCRCallback<Object>() {
public Object doInJCR(JCRSessionWrapper session) throws RepositoryException {
return session.getNodeByUUID(uuid, checkVersion);
}
});
}
if (checkVersion && (versionDate != null || versionLabel != null)) {
wrapper = getFrozenVersionAsRegular(n, provider);
}
sessionCacheByIdentifier.put(uuid, wrapper);
sessionCacheByPath.put(wrapper.getPath(), wrapper);
return wrapper;
} catch (ItemNotFoundException ee) {
// All good
if (originalEx == null) {
originalEx = ee;
}
} catch (UnsupportedRepositoryOperationException uso) {
logger.debug(
"getNodeByUUID unsupported by : "
+ provider.getKey()
+ " / "
+ provider.getClass().getName());
if (originalEx == null) {
originalEx = uso;
}
} catch (RepositoryException ex) {
if (originalEx == null) {
originalEx = ex;
}
logger.warn(
"repository exception : "
+ provider.getKey()
+ " / "
+ provider.getClass().getName()
+ " : "
+ ex.getMessage());
}
}
if (originalEx != null) {
if (originalEx instanceof ItemNotFoundException) {
throw originalEx;
} else {
throw new ItemNotFoundException(uuid, originalEx);
}
}
throw new ItemNotFoundException(uuid);
}
