Overview | Package | Class | Tree | Deprecated | Index | Help
| Copyright © 2000, 2008, Oracle and/or its affiliates. All rights reserved.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.bea.content.spi.flexspi.ticket
Interface NodeOpsV1

All Superinterfaces
  ISPIMarker, ISPITicketMarker, Serializable

    public interface NodeOpsV1

extends Serializable, ISPITicketMarker

NodeOps is a Ticket interface for Node CRUD operations.

It is used to manage Nodes, including their Property values, in a content repository. Nodes are objects in a hierarchy of nodes, which have Properties. Properties have property Values.

NodeOpsV1 rules are defined below.

All Nodes are uniquely identified through:

- 1) their ID, which contains a uid that uniquely identifies it within the repository. This uid may be the path, a database id, etc.
- 2) their path that uniquely identifies it within a repository. The path is a sequence of node names in unix-like format such as /a/b/c where / is the root and a is the name of root's child, b is the name of a's child, etc. Unlike a node retrieved from the VCR, a node passed to/from the SPI has no repository name at the start of its node path -- for example, /repoName/a/b is not possible, but /a/b is possible. The path must always begin with / and never end with it, so neither of the following are valid: a/b/c/d or /a/b/d/d/. Node names must not contain either forward or backslashes.

  The repository root (path /) is an artificial construct and cannot be fetched; no node can have this path. However, it has an ID (UID is empty), and this can be used to retrieve all children at the top level of the repository.

  All Properties are identified through their ID, which includes a uid that uniquely identifies the Property (and containing node) in the repository.

  A Node may either be a Content Node or a Hierarchy Node as defined by its node type, an attribute of a Node. This concept is deprecated; a newly written repository should only support Content nodes.

  If a node has an ObjectClass, it may contain a Property for each PropertyDefinition of its ObjectClass and each Property must match the shape as defined by its corresponding PropertyDefinition. For example, if the ObjectClass has a single-valued property called 'sProp' of type String, a Node of that ObjectClass has a single-valued property called 'sProp' of type String. Properties are associated with PropertyDefinitions by property name.

  Many operations use ID objects as parameters. Before a node has been created, or when a new property is being added, the ID (or UID) may be null, because the property has not been created yet. After a node has been created, it must have a non-null ID (and UID). All nodes (and properties) returned by the repository must have a non-null UID.

  The ID uid will be null when dealing with the repository root node. For all other nodes in the repository, the ID uid must be non-null. For example a call to getNodeChildren(ID id) with a correct repository name and a null uid will return all Nodes at the top level of that repository.

  The repository implementation may have more specific validation rules than those defined above. If a repository considers an attempted operation invalid, it can throw a RepositoryException or UnsupportedRepositoryOperationException. If a repository does not implement a certain operation, it should report this via the method Ticket.getCapabilitySupport(Set capabilities), so applications can detect support for capabilities before attempting them.

  If a Node has an ObjectClass associated with it, whenever it is retrieved, the ObjectClass must be configured on the Node.

  The node's User Properties (the properties defined by the ObjectClass) need not be present on the node when it is returned by the repository. For performance reasons, these can optionally be lazy loaded by the call to Node.getProperties().

  If the repository is returning all properties immmediately, it should set the properties on the returned Node. If the repository wants the properties to be lazy-loaded, it should use NULL for the Node properties on the returned Node.

  The properties approach can be selected on a per-method basis. For the getNode implementations, it is best to initially set the Properties on the return.

  Nested Class Summary
  `static class` | `NodeOpsV1.MethodName`

  Method Summary
  `Node` | `addNodeContent(ID nodeId, ID objectClassId, Property[] properties)` Updates the node with the specified id to contain the specified objectClass and properties (content and meta-content).
  `Node` | `copyNode(ID sourceId, ID destinationId)` This method copies a Node (and its descendents) to a new location in the node hierarchy.
  `Node` | `createNodeWithNodeType(ID parentId, String newNodeName, int type)` This method creates a new Node underneath a parent node.
  `Node` | `createNodeWithNodeTypeAndObjectClass(ID parentId, String newNodeName, int type, ID objectClassId, Property[] properties)` This method creates a new Node underneath a parent node.
  `Node` | `createNodeWithNodeTypeAndObjectClassAndWorkflow(ID parentId, String newNodeName, int type, ID objectClassId, Property[] properties, ID workflowId)` This method creates a new Node underneath a parent node with the specified workflow.
  `Node` | `createNodeWithNodeTypeAndWorkflow(ID parentId, String newNodeName, int type, ID workflowId)` This method creates a new Node underneath a parent node using the specified workflow.
  `void` | `deleteNode(ID nodeId)` This method performs a full cascade delete on a Node and its children.
  `Set<String>` | `getNativeFilterableProperties(String repositoryName)` Returns a set of property names which the repository can filter natively (within the repository instead of the federated API) for methods using a QueryCriteria.
  `Set<String>` | `getNativeSortableProperties(String repositoryName)` Returns a set of property names which the repository can sort natively (within the repository instead of the federated API) for methods using a QueryCriteria.
  `Node[]` | `getNodeChildren(ID parentId, int type)` This method returns an array of all child Nodes for the specified parent Node (and type), which the caller can view.
  `ID[]` | `getNodeChildrenAsNodeIds(ID parentId, int type)` This method returns an array of all child Node IDs for the specified parent Node (and type), which the caller can view.
  `QueryResult<Node>` | `getNodeChildrenWithQueryCriteria(ID parentId, int type, QueryCriteria queryCriteria)` This method returns a QueryResult of all child Nodes for the specified parent Node (and type), which the caller can view, according to the QueryCriteria.
  `ID[]` | `getNodeReferences(ID nodeId)` Retrieve all nodes in this repository which have a link property referring to the specified node.
  `Node[]` | `getNodesWithIds(ID[] nodeIds)` This method retrieves a batch of Nodes, given a batch of Node IDs.
  `QueryResult<Node>` | `getNodesWithIdsAndQueryCriteria(ID[] nodeIds, QueryCriteria queryCriteria, boolean failSilently)` This method retrieves a batch of Nodes, given a batch of Node IDs.
  `Node` | `getNodeWithId(ID nodeId)` This method retrieves a particular Node (and its metadata) based on its ID.
  `Node` | `getNodeWithPath(String path)` This method retrieves a particular Node (and its metadata) based on its path.
  `Property[]` | `getProperties(ID nodeId)` Retrieve all Properties for a Node, except the binary value content of a binary property.
  `InputStream` | `getPropertyBytes(ID propertyId)` Retrieves binary content for the given binary property ID.
  `Node` | `moveNode(ID sourceId, ID destinationId)` This method moves a Node (and its descendents) to a new location in the node hierarchy.
  `void` | `orderBefore(ID parentNodeId, ID srcChildNodeId, ID destChildNodeId)` If the parent node type supports child node ordering, this method inserts the child node at `srcChildNodeId` before its sibling, the child node at `destChildNodeId`.
  `Node` | `removeNodeContent(ID nodeId)` Removes the Node's properties and its ObjectClass.
  `Node` | `renameNode(ID nodeId, String newName)` This method renames a node.
  `Node` | `save(Node node)` This method updates an existing node (and its metadata) in a single transaction.
  `Node` | `updateProperties(ID nodeId, Property[] properties)` Updates the node with the specified id with the specified property values.

  Method Detail

  ### createNodeWithNodeType

      Node createNodeWithNodeType(ID parentId,
                                  String newNodeName,
                                  int type)
                                  throws RepositoryException

    This method creates a new Node underneath a parent node. If the parent ID uid is null then the new Node is created under the repository root node.

    The new Node will be created without an ObjectClass or properties.

    Parameters
      `parentId` - - the id for the parent of the node. The parentId's uid is null if the parent is the repository root node.
      `newNodeName` - - the name of Node to create.
      `type` - - the type of the node, either `Node.HIERARCHY` or `#CONTENT`. Use of Node.HIERARCHY and Node.CONTENT will be deprecated in future releases.
    Returns
      the newly created node.
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NodeExistsException` - - if the parent Node already has a child with the same name.
      `RepositoryException` - - if a validation error occurs.

  ### createNodeWithNodeTypeAndObjectClass

      Node createNodeWithNodeTypeAndObjectClass(ID parentId,
                                                String newNodeName,
                                                int type,
                                                ID objectClassId,
                                                Property[] properties)
                                                throws RepositoryException

    This method creates a new Node underneath a parent node. If the parent ID uid is null then the new Node is created under the repository root node.

    If the ObjectClass is null, the new Node will be created without an ObjectClass. For this case, there will be no properties. The specified Node metadata will be persisted.

    If the ObjectClass is non-null, the new Node will be of the specified ObjectClass, and may contain properties for each property definition in the associated ObjectClass. The property array must be specified. Note that the property IDs may be null, or they may have no UIDs. (since this is a create, there are no UIDs yet).

    If there is a PropertyDefinition in the given ObjectClass with no corresponding Property in the properties array, a Property will be created with a default value, or a null value if there is no default, unless the Property is required, in which case a validation exception will be thrown.

    Parameters
      `parentId` - - the id for the parent of the node. The parentId's uid is null if the parent is the repository root node.
      `newNodeName` - - the name of the Node to create.
      `type` - - the type of the node, either `Node.HIERARCHY` or `#CONTENT`. Use of Node.HIERARCHY and Node.CONTENT will be deprecated in future releases.
      `objectClassId` - - the ID for the ObjectClass to associate the new Node to.
      `properties` - - the properties to add to the new Node. A PropertyDefinition must exist for each property.
    Returns
      the newly created Node.
    Throws
      `AuthorizationException` - for Authorization errors
      `NodeExistsException` - - if the parent Node already has a child with the same name.
      `NoSuchObjectClassException` - - if the ObjectClass doesn't exist.
      `RepositoryException` - - if a validation error occurs.

  ### createNodeWithNodeTypeAndObjectClassAndWorkflow

      Node createNodeWithNodeTypeAndObjectClassAndWorkflow(ID parentId,
                                                           String newNodeName,
                                                           int type,
                                                           ID objectClassId,
                                                           Property[] properties,
                                                           ID workflowId)
                                                           throws RepositoryException

    This method creates a new Node underneath a parent node with the specified workflow. If the parent ID uid is null then the new Node is created under the repository root node.

    If the ObjectClass is null, the new Node will be created without an ObjectClass. For this case, there will be no properties. The specified Node metadata will be persisted.

    If the ObjectClass is non-null, the new Node will be of the specified ObjectClass, and may contain properties for each property definition in the associated ObjectClass. The property array must be specified. Note that the property IDs may be null, or they may have no UIDs. (since this is a create, there are no UIDs yet). Any properties not specified will acquire default values from the ObjectClass PropertyDefinitions.

    If there is a PropertyDefinition in the given ObjectClass with no corresponding Property in the properties array, a Property will be created with a default value, or a null value if there is no default, unless the Property is required, in which case a validation exception will be thrown.

    Parameters
      `parentId` - - the id for the parent of the node. The parentId's uid is null if the parent is the repository root node.
      `newNodeName` - - the name of the Node to create.
      `type` - - the type of the node, either `Node.HIERARCHY` or `#CONTENT`. Use of Node.HIERARCHY and Node.CONTENT will be deprecated in future releases.
      `objectClassId` - - the ID for the ObjectClass to associate the new Node to.
      `properties` - - the properties to add to the new Node. A PropertyDefinition must exist for each property.
      `workflowId` - - the workflow to be associated with the node. If NULL, node uses the default workflow
    Returns
      the newly created Node.
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it
      `NodeExistsException` - - if the parent Node already has a child with the same name.
      `NoSuchObjectClassException` - - if the ObjectClass doesn't exist.
      `RepositoryException` - - if a validation error occurs.

  ### createNodeWithNodeTypeAndWorkflow

      Node createNodeWithNodeTypeAndWorkflow(ID parentId,
                                             String newNodeName,
                                             int type,
                                             ID workflowId)
                                             throws RepositoryException

    This method creates a new Node underneath a parent node using the specified workflow. If the parent ID uid is null then the new Node is created under the repository root node.

    The new Node will be created without an ObjectClass or properties.

    Parameters
      `parentId` - - the id for the parent of the node. The parentId's uid is null if the parent is the repository root node.
      `newNodeName` - - the name of Node to create.
      `type` - - the type of the node, either `Node.HIERARCHY` or `#CONTENT`. Use of Node.HIERARCHY and Node.CONTENT will be deprecated in future releases.
      `workflowId` - - the workflow to be associated with the node. If null, node uses the default workflow
    Returns
      the newly created node.
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NodeExistsException` - - if the parent Node already has a child with the same name.
      `RepositoryException` - - if a validation error occurs.

  ### getNodeWithId

      Node getNodeWithId(ID nodeId)
                         throws RepositoryException

    This method retrieves a particular Node (and its metadata) based on its ID.

    If there is an ObjectClass associated with the Node, then the both the ObjectClass and Node Properties should also be retrieved.

    Parameters
      `nodeId` - - the id for the node to retrieve.
    Returns
      the retrieved Node.
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NoSuchNodeException` - - if the node can't be found.
      `RepositoryException`

  ### getNodeWithPath

      Node getNodeWithPath(String path)
                           throws RepositoryException

    This method retrieves a particular Node (and its metadata) based on its path.

    If there is an ObjectClass associated with the Node, then both the ObjectClass and Node Properties should also be retrieved.

    Parameters
      `path` - - the path for the node to retrieve.
    Returns
      the retrieved Node.
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NoSuchNodeException` - - if the node can't be found
      `RepositoryException`

  ### getNodesWithIds

      Node[] getNodesWithIds(ID[] nodeIds)
                             throws RepositoryException

    This method retrieves a batch of Nodes, given a batch of Node IDs.

    The Node array return value must be the same size as the ID array.

    If the node cannot be found or the current credential is not allowed access to a particular node, a NoSuchNodeException should be thrown.

    Parameters
      `nodeIds` - - the Node IDs to retrieve the Nodes for.
    Returns
      the retrieved Nodes
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NoSuchNodeException` - - if a node cannot be retrieved
      `RepositoryException`

  ### getNodesWithIdsAndQueryCriteria

      QueryResult<Node> getNodesWithIdsAndQueryCriteria(ID[] nodeIds,
                                                        QueryCriteria queryCriteria,
                                                        boolean failSilently)
                                                        throws RepositoryException

    This method retrieves a batch of Nodes, given a batch of Node IDs.

    The QueryResult return value must contain the same number of nodes as the ID array.

    If the node cannot be found or the current credential is not allowed access to a particular node, then the behavior is governed by the failSilently parameter.

    If failSilently is true, then a null should be placed in the returned query result at that node position. If failSilently is false, then a NoSuchNodeException should be thrown.

    Parameters
      `nodeIds` - - the Node IDs to retrieve the Nodes for.
      `queryCriteria` - - the query criteria (possibly unsorted and unfiltered)
      `failSilently` - - if true, then if a node cannot be found, no exception will be thrown
    Returns
      the retrieved Nodes, possibly including null values
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NoSuchNodeException` - - if a node to get cannot be retrieved and failSilently is false
      `RepositoryException`

  ### getNodeChildrenAsNodeIds

      ID[] getNodeChildrenAsNodeIds(ID parentId,
                                    int type)
                                    throws RepositoryException

    This method returns an array of all child Node IDs for the specified parent Node (and type), which the caller can view. If the specified parent Node has no children, then an empty ID array should be returned.

    Parameters
      `parentId` - - the parent Node ID (if uid is null, the repository root node)
      `type` - - the node type of children to return, either `Node.HIERARCHY`, `#CONTENT` or `Node.NODE`. If the type is `Node.NODE` then all children (both `Node.HIERARCHY` and `#CONTENT` will be returned. Use of Node.HIERARCHY and Node.CONTENT will be deprecated in future releases.

    Returns
      one Node ID per child of the parent, or empty array if the Node has no children.
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NoSuchNodeException` - - if the parent node can't be found.
      `RepositoryException`

  ### getNodeChildren

      Node[] getNodeChildren(ID parentId,
                             int type)
                             throws RepositoryException

    This method returns an array of all child Nodes for the specified parent Node (and type), which the caller can view. This returns just the first level of children, it is not recursive. If the specified parent Node has no children, then an empty Node array should be returned.

    Parameters
      `parentId` - - the parent Node ID (if uid is null, the repository root node)
      `type` - - the type of children to return, either `Node.HIERARCHY`, `#CONTENT` or `Node.NODE`. If the type is `Node.NODE` then all children (both `Node.HIERARCHY` and `#CONTENT` will be returned. Use of Node.HIERARCHY and Node.CONTENT will be deprecated in future releases.

    Returns
      one Node per child of the parent, or empty array if the Node has no children.
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NoSuchNodeException` - - if the parent node can't be found.
      `RepositoryException`

  ### getNodeChildrenWithQueryCriteria

      QueryResult<Node> getNodeChildrenWithQueryCriteria(ID parentId,
                                                         int type,
                                                         QueryCriteria queryCriteria)
                                                         throws RepositoryException

    This method returns a QueryResult of all child Nodes for the specified parent Node (and type), which the caller can view, according to the QueryCriteria. If the specified parent Node has no children, then an empty QueryResult should be returned.

    Parameters
      `parentId` - - the parent Node ID (if uid is null, the repository root node)
      `type` - - the type of children to return, either `Node.HIERARCHY`, `#CONTENT` or `Node.NODE`. If the type is `Node.NODE` then all children (both `Node.HIERARCHY` and `#CONTENT` will be returned. Use of Node.HIERARCHY and Node.CONTENT will be deprecated in future releases.

      `queryCriteria` - - the query criteria (possibly unsorted and unfiltered)
    Returns
      one Node per child of the parent, empty if the Node has no children.
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NoSuchNodeException` - - if the parent node can't be found.
      `RepositoryException`

  ### getNodeReferences

      ID[] getNodeReferences(ID nodeId)
                             throws RepositoryException

    Retrieve all nodes in this repository which have a link property referring to the specified node. Note that the specified node may be from a different repository, so it's important to check both the repository name and uid in the nodeId.

    Parameters
      `nodeId` - The `ID` of the referred-to node.
    Returns
      An array of node IDs which refer to the given node, empty if there are no matches.
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it
      `RepositoryException`

  ### orderBefore

      void orderBefore(ID parentNodeId,
                       ID srcChildNodeId,
                       ID destChildNodeId)
                       throws RepositoryException

    If the parent node type supports child node ordering, this method inserts the child node at `srcChildNodeId` before its sibling, the child node at `destChildNodeId`. Both nodes must be immediate children of the parent node, `parentNodeId`. If parentNodeId's uid is null, then the parent node is the repository root node.

    To place the node `srcChildNodeId` at the end of the list, a `destChildNodeId` of `null` is used.

    If `srcChildNodeId` and `destChildNodeId` are the same, then no change is made.

    If this node does not support child node ordering, then a `UnsupportedRepositoryOperationException` is thrown.

    If one of the nodes does not exist, then a `NoSuchNodeException` is thrown.

    If `destChildNodeId` is neither `null` nor a sibling of srcChildNodeId, then a `NoSuchNodeException` is also thrown.

    If this operation would violate a node type or implementation-specific constraint, a `ConstraintViolationException` will be thrown.

    Parameters
      `parentNodeId` - the parent of both srcChildNodeId and destChildNodeId (null uid for repo root)
      `srcChildNodeId` - the child node to be moved in the ordering
      `destChildNodeId` - the child node before which the node `srcChildNodeId` will be placed, or null to move the srcChildNode to the last position.

    Throws
      `ConstraintViolationException` - if an implementation-specific constraint is violated
      `NoSuchNodeException` - if neither child node exists
      `RepositoryException` - if another error occurs
      `AuthorizationException` - if the user attempting the operation is not authorized to perform it

  ### deleteNode

      void deleteNode(ID nodeId)
                      throws RepositoryException

    This method performs a full cascade delete on a Node and its children. The specified node, all its descendant Nodes, and all properties for these nodes are removed in the process.

    Parameters
      `nodeId` - - the id of the Node to be deleted. Cannot be the repository root node. (uid=null)

    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NoSuchNodeException` - - if the node to delete can't be found.
      `RepositoryException` - - if validation error occurs.

  ### moveNode

      Node moveNode(ID sourceId,
                    ID destinationId)
                    throws RepositoryException

    This method moves a Node (and its descendents) to a new location in the node hierarchy.

    The parent for the source node will be changed, but all descendants of the source node will keep their parent relationships intact. The path must be updated for all nodes which were moved.

    If the uid is null for the destinationId, the desination will be the repository root node.

    Parameters
      `sourceId` - - the id of the Node to be moved
      `destinationId` - - the id of the Node under which the sourceId Node is moved. If uid is null, the repository root node.
    Returns
      the moved Node
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NodeExistsException` - - if attempting to move a Node to a location that already exists.
      `NoSuchNodeException` - - if the source or destination node can't be found.
      `RepositoryException` - - if validation error occurs.

  ### copyNode

      Node copyNode(ID sourceId,
                    ID destinationId)
                    throws RepositoryException

    This method copies a Node (and its descendents) to a new location in the node hierarchy.

    Each copied node is a totally separate node, with its own ID, properties, path, etc.

    If the uid is null for the destinationId, the destination will be the repository root.

    Parameters
      `sourceId` - - the id of the Node to be copied
      `destinationId` - - the id of the Node under which the sourceId Node is copied. If uid is null, the repository root node.
    Returns
      the copied Node
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NoSuchNodeException` - - if the source or destination node can't be found.
      `RepositoryException` - - if validation error occurs.

  ### renameNode

      Node renameNode(ID nodeId,
                      String newName)
                      throws RepositoryException

    This method renames a node. This action causes the node and all of its descendents to have their paths updated.

    A Node may not be renamed to have the same name as an existing sibling node.

    Parameters
      `nodeId` - - the id for the node to rename
      `newName` - - a String for the new node name
    Returns
      the renamed Node

    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NoSuchNodeException` - - if the node to rename can't be found.
      `NodeExistsException` - - if the newName already exists as a sibling.
      `RepositoryException` - - if validation error occurs.

  ### addNodeContent

      Node addNodeContent(ID nodeId,
                          ID objectClassId,
                          Property[] properties)
                          throws RepositoryException

    Updates the node with the specified id to contain the specified objectClass and properties (content and meta-content). Each property specified in properties must have an associated PropertyDefinition defined on the ObjectClass. One or more of (new) property IDs may be null or have no UIDs.

    If the node already has an ObjectClass and properties, they will be replaced.

    If there is a PropertyDefinition in the given ObjectClass with no corresponding Property in the properties array, a Property will be created with a default value, or a null value if there is no default, unless the Property is required, in which case a validation exception will be thrown.

    Parameters
      `nodeId` - - the ID for the node to update.
      `objectClassId` - - the ID for new objectClass.
      `properties` - - the new properties on the Node. Additional unspecified properties may also exist.
    Returns
      the updated Node.
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NoSuchObjectClassException` - thrown if the ObjectClass to set on the Node does not exist.
      `NoSuchNodeException` - - if the Node to update does not exist.
      `RepositoryException` - - if validation error occurs.

  ### updateProperties

      Node updateProperties(ID nodeId,
                            Property[] properties)
                            throws RepositoryException

    Updates the node with the specified id with the specified property values.

    The node must already have an ObjectClass associated with it. Each property specified in properties must have an associated PropertyDefinition defined on the ObjectClass. One or more of (new) property IDs may be null or have no UIDs.

    This method only updates the specified properties; the Node may have additional existing properties, and if they are not in the properties array, then they will not be modified.

    Parameters
      `nodeId` - - the ID of the node to update. The ID must include the repositoryName.
      `properties` - - the properties to update on the Node. Existing unspecified properties may also exist.
    Returns
      the updated Node.
    Throws
      `AuthenticationException` - - if the user attempting the operation isn't authenticated against the repository.
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NoSuchNodeException` - - if the Node to update does not exist.
      `NoSuchPropertyException` - - if a Property does not exist on the Node.
      `RepositoryException` - - if system or validation error occurs.

  ### save

      Node save(Node node)
                throws RepositoryException

    This method updates an existing node (and its metadata) in a single transaction. The metadata will be updated as specified, including changed properties. The Node's properties will be set to the properties of the node argument.

    If some property values are not specified on the incoming node argument, they will be cleared (made null).

    This is a less granular way of performing similar actions like addNodeContent, moveNode, renameNode, and updateProperties. Additionally this provides access to modify a node's workflow status and workflow id.

    The node is assumed to be retrieved from this API and therefore properly formed when this call is made.

    The following node metadata are system managed, and cannot be modified via this API. created by, created date, modified by, modified date and path (modifying the parent node name will cause the node path to be updated properly).

    Parameters
      `node` - The node to update with the new state configured.
    Returns
      The updated node
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `RepositoryException` - - if validation error occurs.

  ### removeNodeContent

      Node removeNodeContent(ID nodeId)
                             throws RepositoryException

    Removes the Node's properties and its ObjectClass. The node is not removed.

    Parameters
      `nodeId` - - the id for the Node to remove the ObjectClass (and properties) from.
    Returns
      the updated Node.
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NoSuchNodeException` - if the node does not exist.
      `RepositoryException` - - if validation error occurs.

  ### getProperties

      Property[] getProperties(ID nodeId)
                               throws RepositoryException

    Retrieve all Properties for a Node, except the binary value content of a binary property.

    For binary properties, the BinaryValue will not contain the binary content (though the mime type and other binary properties will be retrieved). To retrieve a binary property value, a call to (@link #getPropertyBytes} is necessary.

    Parameters
      `nodeId` - - the id for the node.
    Returns
      An array of Node Properties, an empty array if a node has no properties or ObjectClass.
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NoSuchNodeException` - - if the node can't be found.
      `RepositoryException`

  ### getPropertyBytes

      InputStream getPropertyBytes(ID propertyId)
                                   throws RepositoryException

    Retrieves binary content for the given binary property ID.

    Parameters
      `propertyId` - - the id for the binary property that contains the binary data.

    Returns
      An `InputStream` containing the binary data for the given property id. The caller must close the InputStream.
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `NoSuchPropertyException` - - if the Property does not exist.
      `RepositoryException`

  ### getNativeSortableProperties

      Set<String> getNativeSortableProperties(String repositoryName)
                                              throws RepositoryException

    Returns a set of property names which the repository can sort natively (within the repository instead of the federated API) for methods using a QueryCriteria.

    Parameters
      `repositoryName` - The name of the repository.
    Returns
      The property names which can be sorted at the repository level.
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `RepositoryException` - - if validation error occurs.

  ### getNativeFilterableProperties

      Set<String> getNativeFilterableProperties(String repositoryName)
                                                throws RepositoryException

    Returns a set of property names which the repository can filter natively (within the repository instead of the federated API) for methods using a QueryCriteria.

    Parameters
      `repositoryName` - The name of the repository.
    Returns
      The property names which can be filtered at the repository level.
    Throws
      `AuthorizationException` - - if the user attempting the operation is not authorized to perform it.
      `RepositoryException` - - if validation error occurs.

  Overview | Package | Class | Tree | Deprecated | Index | Help
  PREV CLASS NEXT CLASS | FRAMES NO FRAMES
  SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

  Copyright © 2000, 2008, Oracle and/or its affiliates. All rights reserved.
  Oracle is a registered trademark of Oracle Corporation and/or its affiliates.
  Other names may be trademarks of their respective owners.