javax.jcr.ItemNotFoundException Java Examples

protected Node checkId(String id) throws NotFoundException {
	// TODO improve
	try {
		return getTemplate().getNodeByUUID(id);
	} catch (DataRetrievalFailureException e) {
		if (e.getCause() instanceof ItemNotFoundException) {
			throw new NotFoundException("Id '" + id + "' not found");
		}
		
		throw e;
	}		
}
 

@Override
public String getStoredQueryPath() throws ItemNotFoundException, RepositoryException {
    try {
        return delegate.getStoredQueryPath();
    } catch (ItemNotFoundException ex) {
        try {
            return delegate.getStoredQueryPath();
        } catch (ItemNotFoundException ignore) {
            throw ex;
        }
    }
}
 

@Override
@Nonnull
public Node getParent() throws ItemNotFoundException, RepositoryException {
    if (session.getRootNode() == this) throw new ItemNotFoundException();
    if (Strings.isNullOrEmpty(Paths.parent(path))) return session.getRootNode();
    return session.getNode(Paths.parent(path));
}
 

@Override
@Nullable
public Item getAncestor(int depth) throws ItemNotFoundException, RepositoryException {
    int myDepth = getDepth();
    if (depth > myDepth) throw new ItemNotFoundException();
    return (depth < myDepth) ? ((NodeImpl)getParent()).getAncestor(depth) : null;
}
 

private NodeImpl createNode(@Nonnull String path, @Nonnull Map<String, Object> properties) throws ItemNotFoundException, ItemExistsException {
    NodeImpl node = new NodeImpl((SessionImpl)session, path);

    for (String propName : properties.keySet()) {
        Object mapVal = properties.get(propName);
        setNodeProperty(node, propName, mapVal);
    }
    return node;
}
 

Item addItem(@Nonnull ItemImpl item) throws ItemNotFoundException, ItemExistsException {
    if (itemStore.containsKey(item.getPath())) throw new ItemExistsException();
    addedItems.add(item.getPath());
    return storeItem(item);
}
 

/**
 * Jcr exception translator - it converts specific JSR-170 checked exceptions into unchecked Spring DA
 * exception.
 * @author Guillaume Bort <[email protected]>
 * @author Costin Leau
 * @author Sergio Bossa
 * @author Salvatore Incandela
 * @param ex
 * @return
 */
public static DataAccessException translateException(RepositoryException ex) {
    if (ex instanceof AccessDeniedException) {
        return new DataRetrievalFailureException("Access denied to this data", ex);
    }
    if (ex instanceof ConstraintViolationException) {
        return new DataIntegrityViolationException("Constraint has been violated", ex);
    }
    if (ex instanceof InvalidItemStateException) {
        return new ConcurrencyFailureException("Invalid item state", ex);
    }
    if (ex instanceof InvalidQueryException) {
        return new DataRetrievalFailureException("Invalid query", ex);
    }
    if (ex instanceof InvalidSerializedDataException) {
        return new DataRetrievalFailureException("Invalid serialized data", ex);
    }
    if (ex instanceof ItemExistsException) {
        return new DataIntegrityViolationException("An item already exists", ex);
    }
    if (ex instanceof ItemNotFoundException) {
        return new DataRetrievalFailureException("Item not found", ex);
    }
    if (ex instanceof LoginException) {
        return new DataAccessResourceFailureException("Bad login", ex);
    }
    if (ex instanceof LockException) {
        return new ConcurrencyFailureException("Item is locked", ex);
    }
    if (ex instanceof MergeException) {
        return new DataIntegrityViolationException("Merge failed", ex);
    }
    if (ex instanceof NamespaceException) {
        return new InvalidDataAccessApiUsageException("Namespace not registred", ex);
    }
    if (ex instanceof NoSuchNodeTypeException) {
        return new InvalidDataAccessApiUsageException("No such node type", ex);
    }
    if (ex instanceof NoSuchWorkspaceException) {
        return new DataAccessResourceFailureException("Workspace not found", ex);
    }
    if (ex instanceof PathNotFoundException) {
        return new DataRetrievalFailureException("Path not found", ex);
    }
    if (ex instanceof ReferentialIntegrityException) {
        return new DataIntegrityViolationException("Referential integrity violated", ex);
    }
    if (ex instanceof UnsupportedRepositoryOperationException) {
        return new InvalidDataAccessApiUsageException("Unsupported operation", ex);
    }
    if (ex instanceof ValueFormatException) {
        return new InvalidDataAccessApiUsageException("Incorrect value format", ex);
    }
    if (ex instanceof VersionException) {
        return new DataIntegrityViolationException("Invalid version graph operation", ex);
    }
    // fallback
    return new JcrSystemException(ex);
}
 

@Override
public String getStoredQueryPath() throws ItemNotFoundException, RepositoryException {
    return null;
}
 

@Override
public Property getProperty() throws ItemNotFoundException, ValueFormatException, RepositoryException {
    return null;  //not implemented
}
 

@Override
public Node getNode() throws ItemNotFoundException, ValueFormatException, RepositoryException {
    return null;  //not implemented
}
 

public PropertyImpl(@Nonnull SessionImpl session, @Nonnull String path) throws ItemNotFoundException, ItemExistsException {
    super(session, path);
}
 

@Override
public String getCorrespondingNodePath(String workspaceName) throws ItemNotFoundException, NoSuchWorkspaceException, AccessDeniedException, RepositoryException {
    return null;  //Not Implemented
}
 

@Override
public Item getPrimaryItem() throws ItemNotFoundException, RepositoryException {
    return null;  //Not implemented
}
 

@Override
public void orderBefore(String srcChildRelPath, String destChildRelPath) throws UnsupportedRepositoryOperationException, VersionException, ConstraintViolationException, ItemNotFoundException, LockException, RepositoryException {
    throw new UnsupportedRepositoryOperationException();
}
 

/**
 * Construct a new NodeImpl.
 */
public NodeImpl(@Nonnull SessionImpl session, String path) throws ItemNotFoundException, ItemExistsException {
    super(session, path);
}
 

private Item storeItem(@Nonnull ItemImpl item) throws ItemNotFoundException {
    itemStore.put(item.getPath(), item);
    return item;
}
 

Item changeItem(@Nonnull ItemImpl item) throws ItemNotFoundException {
    if (!addedItems.contains(item.getPath()))
        changedItems.add(item.getPath());
    return storeItem(item);
}
 

@Override
public String getStoredQueryPath() throws ItemNotFoundException, RepositoryException {
    return null;
}
 

@Override
public Node getNodeByIdentifier(String id) throws ItemNotFoundException, RepositoryException {
    return null;  //TODO: Implement IDs
}
 

@Override
public Node getNodeByUUID(String uuid) throws ItemNotFoundException, RepositoryException {
    return null;  //TODO: Implement IDs
}
 

@Override
public Node getNodeByIdentifier(String id) throws ItemNotFoundException, RepositoryException {
    return objectWrapper.wrap(this, wrappedSession.getNodeByIdentifier(id));
}
 

@Override
public Node getNodeByUUID(String uuid) throws ItemNotFoundException, RepositoryException {
    return objectWrapper.wrap(this, wrappedSession.getNodeByUUID(uuid));
}
 

@Override
public Node getParent() throws ItemNotFoundException, AccessDeniedException, RepositoryException {
    return this.sessionWrapper.getNode(this.delegate.getParent().getPath());
}
 

@Override
public Item getAncestor(int depth) throws ItemNotFoundException, AccessDeniedException, RepositoryException {
    return this.sessionWrapper.getItem(this.delegate.getAncestor(depth).getPath());
}
 

@Override
public Property getProperty() throws ItemNotFoundException, ValueFormatException, RepositoryException {
    return this.sessionWrapper.getProperty(delegate.getProperty().getPath());
}
 

@Override
public Node getNode() throws ItemNotFoundException, ValueFormatException, RepositoryException {
    return this.sessionWrapper.getNode(delegate.getNode().getPath());
}
 

@Override
public String getCorrespondingNodePath(String workspaceName) throws ItemNotFoundException, NoSuchWorkspaceException, AccessDeniedException, RepositoryException {
    return this.delegate.getCorrespondingNodePath(workspaceName);
}
 

@Override
public Item getPrimaryItem() throws ItemNotFoundException, RepositoryException {
    return sessionWrapper.getObjectWrapper().wrap(sessionWrapper, delegate.getPrimaryItem());
}
 

@Override
public void orderBefore(String srcChildRelPath, String destChildRelPath) throws UnsupportedRepositoryOperationException, VersionException, ConstraintViolationException, ItemNotFoundException, LockException, RepositoryException {
    this.delegate.orderBefore(srcChildRelPath, destChildRelPath);
}
 

@Override
public Value getValue(String columnName) throws ItemNotFoundException, RepositoryException {
    return value;
}