Interface ConfluenceSoapService

All Superinterfaces:
SecureRpc
All Known Implementing Classes:
WikiSoapService, XhtmlSoapService

public interface ConfluenceSoapService extends SecureRpc
  • Field Details

  • Method Details

    • login

      String login(String username, String password) throws RemoteException
      Specified by:
      login in interface SecureRpc
      Throws:
      RemoteException
    • logout

      boolean logout(String token) throws RemoteException
      Specified by:
      logout in interface SecureRpc
      Throws:
      RemoteException
    • getSpaces

      RemoteSpaceSummary[] getSpaces(String token) throws RemoteException
      Throws:
      RemoteException
    • getSpacesInGroup

      RemoteSpaceSummary[] getSpacesInGroup(String token, String spaceGroupKey) throws RemoteException
      Throws:
      RemoteException
    • addSpaceWithDefaultPermissions

      RemoteSpace addSpaceWithDefaultPermissions(String token, RemoteSpace space) throws RemoteException
      Throws:
      RemoteException
    • addSpace

      RemoteSpace addSpace(String token, RemoteSpace space) throws RemoteException
      Throws:
      RemoteException
    • storeSpace

      RemoteSpace storeSpace(String token, RemoteSpace remoteSpace) throws RemoteException
      Allows for modifying space details via the remote API. Currently you can update the following space properties:

      • Name
      • Homepage
      • SpaceGroup
      Parameters:
      remoteSpace -
      Returns:
      the updated space
      Throws:
      RemoteException
    • addSpaceGroup

      @Deprecated RemoteSpaceGroup addSpaceGroup(String token, RemoteSpaceGroup spaceGroup) throws RemoteException
      Deprecated.
      since 5.9.

      SpaceGroup and related classes like SpaceGroupManager and SpaceGroupComparator will be removed. Please do not use them.

      Add a space Group to Confluence
      Parameters:
      token - the authentication token
      spaceGroup - the spacegroup to add
      Returns:
      the space group
      Throws:
      NotPermittedException - if the user lacks permissions to perform the action
      InvalidSessionException
      AlreadyExistsException - if a group with the same key already exists
      RemoteException
    • getSpaceGroup

      @Deprecated RemoteSpaceGroup getSpaceGroup(String token, String spaceGroup) throws RemoteException
      Deprecated.
      since 5.9.

      SpaceGroup and related classes like SpaceGroupManager and SpaceGroupComparator will be removed. Please do not use them.

      Throws:
      RemoteException
    • getSpaceGroups

      @Deprecated RemoteSpaceGroup[] getSpaceGroups(String token) throws RemoteException
      Deprecated.
      since 5.9.

      SpaceGroup and related classes like SpaceGroupManager and SpaceGroupComparator will be removed. Please do not use them.

      Throws:
      RemoteException
    • removeSpaceGroup

      @Deprecated boolean removeSpaceGroup(String token, String spaceGroupKey) throws RemoteException
      Deprecated.
      since 5.9.

      SpaceGroup and related classes like SpaceGroupManager and SpaceGroupComparator will be removed. Please do not use them.

      Removes a Space Group from Confluence without removing the space it contains. Currently requires global administration rights
      Parameters:
      token - the authentication token
      spaceGroupKey - the id of the spacegroup to be removed
      Returns:
      true, if the space group was removed
      Throws:
      RemoteException
    • addPersonalSpace

      RemoteSpace addPersonalSpace(String token, RemoteSpace space, String username) throws RemoteException
      Throws:
      RemoteException
    • addPersonalSpaceWithDefaultPermissions

      RemoteSpace addPersonalSpaceWithDefaultPermissions(String token, RemoteSpace space, String username) throws RemoteException
      Throws:
      RemoteException
    • removeSpace

      Boolean removeSpace(String token, String spaceKey) throws RemoteException
      Throws:
      RemoteException
    • getSpace

      RemoteSpace getSpace(String token, String spaceKey) throws RemoteException
      Throws:
      RemoteException
    • getSpaceStatus

      String getSpaceStatus(String token, String spaceKey) throws RemoteException
      Throws:
      RemoteException
    • setSpaceStatus

      Boolean setSpaceStatus(String token, String spaceKey, String status) throws RemoteException
      Throws:
      RemoteException
    • getPermissions

      String[] getPermissions(String token, String spaceKey) throws RemoteException
      Throws:
      RemoteException
    • getPermissionsForUser

      String[] getPermissionsForUser(String token, String spaceKey, String userName) throws RemoteException
      Throws:
      RemoteException
    • getSpacePermissionSets

      RemoteSpacePermissionSet[] getSpacePermissionSets(String token, String spaceKey) throws RemoteException
      Throws:
      RemoteException
    • getSpacePermissionSet

      RemoteSpacePermissionSet getSpacePermissionSet(String token, String spaceKey, String permissionType) throws RemoteException
      Throws:
      RemoteException
    • addPermissionToSpace

      boolean addPermissionToSpace(String token, String permission, String remoteEntityName, String spaceKey) throws RemoteException
      Add a Space Permission for a user or group
      Parameters:
      token - the authentication token
      permission - the Space Permission to add
      remoteEntityName - the name of the user or group
      spaceKey - the key of the Space affected by this action
      Returns:
      True if successful, false otherwise
      Throws:
      RemoteException - if the Space Permission is null
      RemoteException - if the Space does not exist
      NotPermittedException - if the user lacks permissions to perform the action
      RemoteException - if the remoteEntityName is null or does not match a user or group
    • addPermissionsToSpace

      boolean addPermissionsToSpace(String token, String[] permissions, String remoteEntityName, String spaceKey) throws RemoteException
      Add Space Permissions for a user or group
      Parameters:
      token - the authentication token
      permissions - the Space Permissions to add
      remoteEntityName - the name of the user or group
      spaceKey - the key of the Space affected by this action
      Returns:
      True if successful, false otherwise
      Throws:
      RemoteException - if the Space Permissions array is null
      RemoteException - if the Space does not exist
      NotPermittedException - if the user lacks permissions to perform the action
      RemoteException - if the remoteEntityName is null or does not match a user or group
      Since:
      2.0
    • removePermissionFromSpace

      boolean removePermissionFromSpace(String token, String permission, String remoteEntityName, String spaceKey) throws RemoteException
      Removes a Space Permission for a user or group
      Parameters:
      token - the authentication token
      permission - the Space Permission to remove
      remoteEntityName - the name of the user or group
      spaceKey - the key of the Space affected by this action
      Returns:
      True if successful, false otherwise
      Throws:
      RemoteException - if the Space does not exist
      NotPermittedException - if the user lacks permissions to perform the action
      RemoteException - if the remoteEntityName is null or does not match a user or group
    • addAnonymousPermissionToSpace

      boolean addAnonymousPermissionToSpace(String token, String permission, String spaceKey) throws RemoteException
      Add a Space Permission for anonymous users
      Parameters:
      token - the authentication token
      permission - the Space Permission to add
      spaceKey - the key of the Space affected by this action
      Returns:
      True if successful, false otherwise
      Throws:
      RemoteException - if the Space Permission is null
      RemoteException - if the Space does not exist
      NotPermittedException - if the user lacks permissions to perform the action
      RemoteException - if the remoteEntityName is null or does not match a user or group
      Since:
      2.0
    • addAnonymousPermissionsToSpace

      boolean addAnonymousPermissionsToSpace(String token, String[] permissions, String spaceKey) throws RemoteException
      Add Space Permissions for anonymous users
      Parameters:
      token - the authentication token
      permissions - the Space Permissions to add
      spaceKey - the key of the Space affected by this action
      Returns:
      True if successful, false otherwise
      Throws:
      RemoteException - if the Space Permissions array is null
      RemoteException - if the Space does not exist
      NotPermittedException - if the user lacks permissions to perform the action
      RemoteException - if the remoteEntityName is null or does not match a user or group
      Since:
      2.0
    • removeAnonymousPermissionFromSpace

      boolean removeAnonymousPermissionFromSpace(String token, String permission, String spaceKey) throws RemoteException
      Removes a Space Permission for anonymous users
      Parameters:
      token - the authentication token
      permission - the Space Permission to remove
      spaceKey - the key of the Space affected by this action
      Returns:
      True if successful, false otherwise
      Throws:
      RemoteException - if the Space does not exist
      NotPermittedException - if the user lacks permissions to perform the action
      RemoteException - if the remoteEntityName is null or does not match a user or group
      Since:
      2.0
    • getPagePermissions

      RemotePermission[] getPagePermissions(String token, long pageId) throws RemoteException
      Throws:
      RemoteException
    • getSpaceLevelPermissions

      String[] getSpaceLevelPermissions(String token) throws RemoteException
      Throws:
      RemoteException
    • getPages

      RemotePageSummary[] getPages(String token, String spaceKey) throws RemoteException
      Returns all pages of the space with the given spaceKey the user authenticated by token is allowed to view. The result is not ordered.
      Parameters:
      token - the authentication token
      spaceKey - the key of the space which pages are to be returned
      Throws:
      RemoteException
    • getPage

      RemotePage getPage(String token, String spaceKey, String pageTitle) throws RemoteException
      Throws:
      RemoteException
    • getPageSummary

      RemotePageSummary getPageSummary(String token, String spaceKey, String pageTitle) throws RemoteException
      Throws:
      RemoteException
    • getPage

      RemotePage getPage(String token, long pageId) throws RemoteException
      Throws:
      RemoteException
    • getPageSummary

      RemotePageSummary getPageSummary(String token, long pageId) throws RemoteException
      Throws:
      RemoteException
    • storePage

      RemotePage storePage(String token, RemotePage page) throws RemoteException
      Throws:
      RemoteException
    • updatePage

      RemotePage updatePage(String token, RemotePage page, RemotePageUpdateOptions options) throws RemoteException
      Throws:
      RemoteException
    • movePageToTopLevel

      Boolean movePageToTopLevel(String token, long pageId, String targetSpaceKey) throws RemoteException
      Throws:
      RemoteException
    • movePage

      Boolean movePage(String token, long sourcePageId, long targetPageId, String position) throws RemoteException
      Throws:
      RemoteException
    • removePage

      Boolean removePage(String token, long pageId) throws RemoteException
      Throws:
      RemoteException
    • removePageVersionById

      Boolean removePageVersionById(String token, long historicalPageId) throws RemoteException
      Remove a historical version of a page. The id supplied must identify a historical version of a page rather than the latest version of the page. If you want to remove the latest version of a page and its full version history then see removePage(String, long).
      Parameters:
      token -
      historicalPageId - the id of a historical version of a page
      Returns:
      true if successfully remove, otherwise false.
      Throws:
      NotPermittedException
      InvalidSessionException
      RemoteException
    • removePageVersionByVersion

      Boolean removePageVersionByVersion(String token, long pageId, int version) throws RemoteException
      Remove the identified version of a page. The pageId must identify a current page.
      Parameters:
      token -
      pageId - the id of the page which you want to remove a version from.
      version - the version of the page to be removed (with 1 being the first).
      Returns:
      true if successful; otherwise false.
      Throws:
      NotPermittedException
      InvalidSessionException
      RemoteException
    • getTrashContents

      RemoteContentSummaries getTrashContents(String token, String spaceKey, int offset, int count) throws RemoteException
      Throws:
      RemoteException
    • purgeFromTrash

      Boolean purgeFromTrash(String token, String spaceKey, long pageId) throws RemoteException
      Throws:
      RemoteException
    • emptyTrash

      Boolean emptyTrash(String token, String spaceKey) throws RemoteException
      Throws:
      RemoteException
    • getTopLevelPages

      RemotePageSummary[] getTopLevelPages(String token, String spaceKey) throws RemoteException
      Returns all top level pages of the space with the given spaceKey the user authenticated by token is allowed to view. The result is ordered by child page order.
      Parameters:
      token - the authentication token
      spaceKey - the key of the space which pages are to be returned
      Throws:
      RemoteException
    • getAncestors

      RemotePageSummary[] getAncestors(String token, long pageId) throws RemoteException
      Returns all direct ancestor pages of the page with the given pageId the user authenticated by token is allowed to view. The result is not ordered.
      Parameters:
      token - the authentication token
      pageId - the id of the page which child pages are to be returned
      Throws:
      RemoteException
    • getChildren

      RemotePageSummary[] getChildren(String token, long pageId) throws RemoteException
      Returns all child pages of the page with the given pageId the user authenticated by token is allowed to view. The result is ordered by child page order.
      Parameters:
      token - the authentication token
      pageId - the id of the page which child pages are to be returned
      Throws:
      RemoteException
    • getDescendents

      RemotePageSummary[] getDescendents(String token, long pageId) throws RemoteException
      Returns all descendent pages of the page with the given pageId the user authenticated by token is allowed to view. The result is not ordered.
      Parameters:
      token - the authentication token
      pageId - the id of the page which child pages are to be returned
      Throws:
      RemoteException
    • getAttachments

      RemoteAttachment[] getAttachments(String token, long pageId) throws RemoteException
      Throws:
      RemoteException
    • getPageHistory

      RemotePageHistory[] getPageHistory(String token, long pageId) throws RemoteException
      Throws:
      RemoteException
    • watchPage

      boolean watchPage(String token, long pageId) throws RemoteException
      Adds a watch for the current user on the page or blog post with the specified page ID.
      Returns:
      true if the watch was added, or false if it already exists
      Throws:
      RemoteException - if the watch could not be added
    • watchSpace

      boolean watchSpace(String token, String spaceKey) throws RemoteException
      Adds a watch for the current user on the space with the specified space key.
      Returns:
      true if the watch was added, or false if it already exists
      Throws:
      RemoteException - if the watch could not be added
    • watchPageForUser

      boolean watchPageForUser(String token, long pageId, String username) throws RemoteException
      Adds a watch to a specific page or blog post for a particular user. This is only permitted for administrators of the space containing the page or blog post.
      Returns:
      true if the watch was added, or false if it already exists
      Throws:
      RemoteException - if the watch could not be added, or the current user does not have permission to add it
    • removePageWatch

      boolean removePageWatch(String token, long pageId) throws RemoteException
      Remove a watch for the current user on the page or blog post with the specified page ID.
      Returns:
      true if the watch was removed, or false if it doesn't exist
      Throws:
      RemoteException - if the watch could not be removed
    • removeSpaceWatch

      boolean removeSpaceWatch(String token, String spaceKey) throws RemoteException
      Removes a watch for the current user on the space with the specified space key.
      Returns:
      true if the watch was remove, or false if it doesn't exist
      Throws:
      RemoteException - if the watch could not be removed
    • removePageWatchForUser

      boolean removePageWatchForUser(String token, long pageId, String username) throws RemoteException
      Removes a watch from a specific page or blog post for a particular user. This is only permitted for administrators of the space containing the page or blog post.
      Returns:
      true if the watch was removed, or false if it doesn't exist
      Throws:
      RemoteException - if the watch could not be removed, or the current user does not have permission to remove it
    • isWatchingPage

      boolean isWatchingPage(String token, long pageId, String username) throws RemoteException
      Returns true if the specified user is watching the page or blog post with the given ID, otherwise false. This information is only available to administrators of the space containing the page or blog post, if the username is not the same as the current user's.
      Returns:
      true if the user is watching the page, otherwise false
      Throws:
      RemoteException - if the current user does not have permission to see the page or administer the space, or if the page or user does not exist
    • isWatchingSpace

      boolean isWatchingSpace(String token, String spaceKey, String username) throws RemoteException
      Returns true if the specified user is watching the space with the given key, otherwise false. This information is only available to administrators of the space if the username is not the same as the current user's.
      Returns:
      true if the user is watching the space, otherwise false
      Throws:
      RemoteException - if the current user does not have permission to administer the space, or if the user does not exist
    • isWatchingSpaceForType

      boolean isWatchingSpaceForType(String token, String spaceKey, String contentType, String username) throws RemoteException
      Returns true if the specified user is watching the specified type of content in space with the given key, otherwise false. This information is only available to administrators of the space if the username is not the same as the current user's.

      Note that this method will return false if the user is watching the entire space and not just the given type.

      Returns:
      true if the user is watching the space for the type, otherwise false
      Throws:
      RemoteException - if the current user does not have permission to administer the space, or if the user does not exist
    • getWatchersForPage

      RemoteUser[] getWatchersForPage(String token, long pageId) throws RemoteException
      Returns the list of users watching the page or blog post with the given ID. This information is only available to administrators of the space containing the page or blog post.
      Returns:
      the list of users watching the page
      Throws:
      RemoteException - if the current user does not have permission to see the page or administer the space, or if the page does not exist
    • getWatchersForSpace

      RemoteUser[] getWatchersForSpace(String token, String spaceKey) throws RemoteException
      Returns the list of users watching the space with the given key. This information is only available to administrators of the space.
      Returns:
      the list of users watching the space
      Throws:
      RemoteException - if the current user does not have permission to administer the space, or if the space does not exist
    • renderContent

      String renderContent(String token, String spaceKey, long pageId, String newContent) throws RemoteException
      Throws:
      RemoteException
    • renderContent

      String renderContent(String token, String spaceKey, long pageId, String newContent, Map renderParameters) throws RemoteException
      Throws:
      RemoteException
    • convertWikiToStorageFormat

      String convertWikiToStorageFormat(String token, String markup) throws RemoteException
      Converts a string from wiki markup to the XHTML based storage format.
      Returns:
      a string converted to the storage format
      Throws:
      RemoteException
    • addAttachment

      RemoteAttachment addAttachment(String token, long contentId, RemoteAttachment attachment, byte[] attachmentData) throws RemoteException
      Add a new attachment to a ContentEntityObject.
      Parameters:
      token - the authentication token
      contentId - the id of the ContentEntityObject to receive the new attachment.
      attachment - RemoteAttachment object containing attachment information
      attachmentData - a byte[] continaing the contents of the attachment.
      Returns:
      the newly created attachment
      Throws:
      RemoteException
      Since:
      2.0
    • getAttachment

      RemoteAttachment getAttachment(String token, long contentId, String fileName, int version) throws RemoteException
      Retrieve information about an attachment.
      Parameters:
      token - the authentication token.
      contentId - the id of the ContentEntityObject the attachemt belongs to.
      fileName - the name of the attachment.
      version - the version number of the attachment.
      Returns:
      the attachment
      Throws:
      RemoteException
      Since:
      2.0
    • getAttachmentData

      byte[] getAttachmentData(String token, long contentId, String fileName, int version) throws RemoteException
      Retrieve the contents of an attachment.
      Parameters:
      token - the authentication token.
      contentId - the id of the ContentEntityObject the attachemt belongs to.
      fileName - the name of the attachment.
      version - the version number of the attachment.
      Returns:
      the attachment's data
      Throws:
      RemoteException
      Since:
      2.0
    • removeAttachment

      boolean removeAttachment(String token, long contentId, String fileName) throws RemoteException
      Remove an attachment.
      Parameters:
      token - the authentication token.
      contentId - the id of the ContentEntityObject the attachment belongs to.
      fileName - the name of the attachment.
      Returns:
      true if the attachment was deleted.
      Throws:
      RemoteException
      Since:
      2.0
    • moveAttachment

      boolean moveAttachment(String token, long originalContentId, String originalFileName, long newContentId, String newFileName) throws RemoteException
      Move or rename an attachment
      Parameters:
      token - the authentication token.
      originalContentId - the id of the ContentEntityObject the attachment belongs to.
      originalFileName - the name of the attachment.
      newContentId - the id of the ContentEntityObject the attachment is to be moved to.
      newFileName - the name the attachment is to be renamed to.
      Returns:
      true
      Throws:
      RemoteException
      Since:
      2.0
    • getComments

      RemoteComment[] getComments(String token, long pageId) throws RemoteException
      Retrieves the comments for a given abstract page
      Parameters:
      token - the authentication token
      pageId - the content ID of the abstract page
      Returns:
      RemoteComment object with the comment details
      Throws:
      InvalidSessionException
      RemoteException - if the object for the pageId is null, or the user lacks permissions
    • getComment

      RemoteComment getComment(String token, long commentId) throws RemoteException
      Retrieves a comment with the given ID
      Parameters:
      token - The token identifying the current user
      commentId - The ID of the comment to be retrieved
      Returns:
      A RemoteComment object containing the comment information
      Throws:
      InvalidSessionException
      RemoteException - if the comment cannot be found
      RemoteException - if the comment cannot be viewed by the user
      RemoteException - if the page the comment is on cannot be viewed by the user
      RemoteException - if the retrieved object is not a comment
      Since:
      2.0
    • addComment

      RemoteComment addComment(String token, RemoteComment comment) throws RemoteException
      Adds a comment to a page or blog post
      Parameters:
      token - The token identifying the current user
      comment - The RemoteComment object containing the comment information
      Returns:
      RemoteComment object
      Throws:
      InvalidSessionException
      RemoteException - if the user does not have permission to view the page the comment is being posted to, or it does not exist
      NotPermittedException - if the user is unable to post the comment
      Since:
      2.0
    • editComment

      RemoteComment editComment(String token, RemoteComment comment) throws RemoteException
      Updates a comment
      Parameters:
      token - The token identifying the current user
      comment - The RemoteComment object containing the comment information
      Returns:
      RemoteComment object
      Throws:
      InvalidSessionException
      RemoteException - if the user does not have permission to view the page the comment is being posted to, or it does not exist
      NotPermittedException - if the user is unable to edit the comment
      Since:
      2.4
    • removeComment

      boolean removeComment(String token, long commentId) throws RemoteException
      Removes a comment with the given ID
      Parameters:
      token - The token identifying the current user
      commentId - The ID of the comment to remove
      Returns:
      True if successful, false otherwise
      Throws:
      InvalidSessionException
      RemoteException - if the user does not have permission to view the page the comment is on, or it does not exist
      RemoteException - if the comment does not exist
      NotPermittedException - if the user does not have permission to remove the comment
      Since:
      2.0
    • search

      RemoteSearchResult[] search(String token, String query, int maxResults) throws RemoteException

      Search Confluence for the supplied query String. Please be sensible in your use of the maxResults parameter. Too large a value will result in this call taking a long time.

      Parameters:
      token - the authentication token
      query - the query term for the search
      maxResults - the maximum number of results to be returned.
      Returns:
      an array of RemoteSearchResults. If there are no results then an empty array will be returned.
      Throws:
      RemoteException
    • search

      RemoteSearchResult[] search(String token, String query, Map params, int maxResults) throws RemoteException

      Search Confluence for the supplied query String. Please be sensible in your use of the maxResults parameter.

      A Map of search criteria can be specified. The following keys are understood -

      • spaceKey - a key representing a single space to limit the search to.
      • type - the type of content to limit the search to.
      • modified - a String representation of a time range.

      Parameters:
      token - the authentication token
      params - a Map<String,String> providing criteria to the search.
      query - the query term for the search
      maxResults - the maximum number of results to be returned.
      Returns:
      an array of RemoteSearchResults. If there are no results then an empty array will be returned.
      Throws:
      RemoteException
    • getBlogEntryByDayAndTitle

      RemoteBlogEntry getBlogEntryByDayAndTitle(String token, String spaceKey, int dayOfMonth, String postTitle) throws RemoteException
      Retrieves a blog post in the Space with the given spaceKey, with the title 'postTitle' and posted on the day 'dayOfMonth'
      Parameters:
      token - the authentication token
      spaceKey - the key of the Space the blog post belongs to
      dayOfMonth - the day of the month the blog post was made
      postTitle - the title of the blog post
      Returns:
      A RemoteBlogEntry object
      Throws:
      RemoteException - if the user does not have permission to view the blog post, or it does not exist
      Since:
      2.0
    • getBlogEntryByDateAndTitle

      RemoteBlogEntry getBlogEntryByDateAndTitle(String token, String spaceKey, int year, int month, int dayOfMonth, String postTitle) throws RemoteException
      Retrieves a blog post in the given space, with the title and date as specified.
      Returns:
      a blog post matching the criteria
      Throws:
      RemoteException - if the user does not have permission to view the blog post or it does not exist
    • getBlogEntry

      RemoteBlogEntry getBlogEntry(String token, long entryId) throws RemoteException
      Throws:
      RemoteException
    • getBlogEntries

      RemoteBlogEntrySummary[] getBlogEntries(String token, String spaceKey) throws RemoteException
      Throws:
      RemoteException
    • storeBlogEntry

      RemoteBlogEntry storeBlogEntry(String token, RemoteBlogEntry blogEntry) throws RemoteException
      Throws:
      RemoteException
    • getServerInfo

      RemoteServerInfo getServerInfo(String token) throws RemoteException
      Throws:
      RemoteException
    • exportSpace

      String exportSpace(String token, String spaceKey, String exportType) throws RemoteException
      Throws:
      RemoteException
    • exportSpace

      String exportSpace(String token, String spaceKey, String exportType, boolean exportAll) throws RemoteException
      Throws:
      RemoteException
    • exportSite

      String exportSite(String token, boolean exportAttachments) throws RemoteException
      Throws:
      RemoteException
    • performBackup

      String performBackup(String token, boolean exportAttachments) throws RemoteException
      Throws:
      RemoteException
    • importSpace

      boolean importSpace(String token, byte[] importData) throws RemoteException
      Import a space in a compressed XML format
      Parameters:
      token - The authentication token
      importData - The contents of the Space export file
      Returns:
      True if successful, otherwise false
      Throws:
      RemoteException - If the space exists or the export file is invalid
      Since:
      2.4
    • flushIndexQueue

      boolean flushIndexQueue(String token) throws RemoteException
      Throws:
      RemoteException
    • clearIndexQueue

      boolean clearIndexQueue(String token) throws RemoteException
      Throws:
      RemoteException
    • recoverMainIndex

      boolean recoverMainIndex(String token) throws RemoteException
      Throws:
      RemoteException
    • getClusterInformation

      RemoteClusterInformation getClusterInformation(String token) throws RemoteException
      Throws:
      RemoteException
    • getClusterNodeStatuses

      RemoteNodeStatus[] getClusterNodeStatuses(String token) throws RemoteException
      Throws:
      RemoteException
    • getGroups

      String[] getGroups(String token) throws RemoteException
      Retrieves a list of user groups
      Parameters:
      token - The token identifying the current user
      Returns:
      An array of group names
      Throws:
      NotPermittedException - if the current user lacks permission to administer
      RemoteException
    • hasGroup

      boolean hasGroup(String token, String groupname) throws RemoteException
      Determines whether a group exists
      Parameters:
      token - the token identifying the current user
      groupname - the group to look up
      Returns:
      True if the user exists, false otherwise
      Throws:
      InvalidSessionException
      RemoteException
      Since:
      2.0
    • addGroup

      boolean addGroup(String token, String groupname) throws RemoteException
      Adds a new group
      Parameters:
      token - The token identifying the current user
      groupname - The name of the group to be added
      Returns:
      True when the group was successfully added, false if it already exists
      Throws:
      NotPermittedException - if the current user lacks permission to administer
      InvalidSessionException
      RemoteException
    • removeGroup

      boolean removeGroup(String token, String groupname, String defaultGroupName) throws RemoteException
      Removes an existing group

      If a valid defaultGroupName is specified, users will be added to the new group (defaultGroupName).

      Parameters:
      token - The token identifying the current user
      groupname - The name of the group to be removed
      defaultGroupName - The name of the group that users will be moved to
      Returns:
      True if successful, false otherwise.
      Throws:
      NotPermittedException - if the current user lacks permission to administer
      InvalidSessionException
      RemoteException - if the given groupname does not exist
      RemoteException - if the given defaultGroupName does not exist
    • removeAllPermissionsForGroup

      boolean removeAllPermissionsForGroup(String token, String groupname) throws RemoteException
      Deletes all global and space permissions for the given group
      Parameters:
      token - The token identifying the current user
      groupname - The group to delete permissions for
      Returns:
      True if successful, false otherwise.
      Throws:
      NotPermittedException - if the current user lacks permission to administer
      RemoteException - if the given groupname does not exist
    • getUserGroups

      String[] getUserGroups(String token, String username) throws RemoteException
      Retrieves the groups that a given user belongs to
      Parameters:
      token - The token identifying the current user
      username - The username to retrieve groups for
      Returns:
      An array of group names as Strings
      Throws:
      NotPermittedException - if the current user lacks permission to administer
      InvalidSessionException
      RemoteException - if the given username does not exist
    • addUserToGroup

      boolean addUserToGroup(String token, String username, String groupname) throws RemoteException
      Parameters:
      token -
      username -
      groupname -
      Returns:
      True if successful, false otherwise
      Throws:
      NotPermittedException - if the current user lacks permission to administer
      InvalidSessionException
      RemoteException - if the given username does not exist
      RemoteException - if the given groupname does not exist
    • removeUserFromGroup

      boolean removeUserFromGroup(String token, String username, String groupname) throws RemoteException
      Removes the given user from a group
      Parameters:
      token - The token identifying the current user
      username - The username to remove from a group
      groupname - The name of the group the user is to be removed from
      Returns:
      True if successful, false otherwise
      Throws:
      NotPermittedException - if the current user lacks permission to administer
      InvalidSessionException
      RemoteException - if the given username does not exist
      RemoteException - if the given groupname does not exist
    • getUserByName

      RemoteConfluenceUser getUserByName(String token, String username) throws RemoteException
      Retrieves a user with the given username.
      Parameters:
      token - The token identifying the current user
      username - The username of the user to be retrieved
      Returns:
      A RemoteConfluenceUser object, containing the user key, username, full name, email and URL
      Throws:
      InvalidSessionException
      RemoteException - if a user with the given username cannot be found
      Since:
      5.2
    • getUserByKey

      RemoteConfluenceUser getUserByKey(String token, String userKey) throws RemoteException
      Retrieves a user with the given user key.
      Parameters:
      token - The token identifying the current user
      userKey - The user key of the user to be retrieved
      Returns:
      A RemoteUser object, containing the user key, username, full name, email and URL
      Throws:
      InvalidSessionException
      RemoteException - if a user with the given user key cannot be found
      Since:
      5.2
    • setUserPreferenceBoolean

      boolean setUserPreferenceBoolean(String token, String username, String key, boolean value) throws RemoteException
      Set a user preference to a boolean value.
      Parameters:
      token - the token identifying the current user
      key - The user preference key
      value - The value
      Throws:
      InvalidSessionException - If the rpc token expired
      RemoteException - If any other exception occurred
    • getUserPreferenceBoolean

      boolean getUserPreferenceBoolean(String token, String username, String key) throws RemoteException
      Get a user preference as a boolean value.
      Parameters:
      token - the token identifying the current user
      key - The user preference key
      Throws:
      InvalidSessionException - If the rpc token expired
      RemoteException - If any other exception occurred (including not being able to find the key)
    • setUserPreferenceLong

      boolean setUserPreferenceLong(String token, String username, String key, long value) throws RemoteException
      Set a user preference to an long integer value.
      Parameters:
      token - the token identifying the current user
      key - The user preference key
      value - The value
      Throws:
      InvalidSessionException - If the rpc token expired
      RemoteException - If any other exception occurred
    • getUserPreferenceLong

      long getUserPreferenceLong(String token, String username, String key) throws RemoteException
      Get a user preference as a long integer value.
      Parameters:
      token - the token identifying the current user
      key - The user preference key
      Throws:
      InvalidSessionException - If the rpc token expired
      RemoteException - If any other exception occurred (including not being able to find the key)
    • setUserPreferenceString

      boolean setUserPreferenceString(String token, String username, String key, String value) throws RemoteException
      Set a user preference to a String value.
      Parameters:
      token - the token identifying the current user
      key - The user preference key
      value - The value
      Throws:
      InvalidSessionException - If the rpc token expired
      RemoteException - If any other exception occurred
    • getUserPreferenceString

      String getUserPreferenceString(String token, String username, String key) throws RemoteException
      Get a user preference as a String value.
      Parameters:
      token - the token identifying the current user
      key - The user preference key
      Throws:
      InvalidSessionException - If the rpc token expired
      RemoteException - If any other exception occurred (including not being able to find the key)
    • hasUser

      boolean hasUser(String token, String username) throws RemoteException
      Determines whether a user exists
      Parameters:
      token - the token identifying the current user
      username - the username to look up
      Returns:
      True if the user exists, false otherwise
      Throws:
      InvalidSessionException
      RemoteException
      Since:
      2.0
    • addUser

      void addUser(String token, RemoteUser remoteUser, String password) throws RemoteException
      Adds a user with the given RemoteUser object and password
      Parameters:
      token - The token identifying the current user
      remoteUser - The object containing the user information
      password - The password of the user
      Throws:
      NotPermittedException - if the current user lacks permissions to create new users
      InvalidSessionException
      RemoteException - if a user with the given username cannot be found
    • addUser

      void addUser(String token, RemoteUser remoteUser, String password, boolean notifyUser) throws RemoteException
      Adds a user with the given RemoteUser object and password
      Parameters:
      token - The token identifying the current user
      remoteUser - The object containing the user information
      password - The password of the user
      notifyUser - Whether or not you want the new user to be notified of their new account
      Throws:
      NotPermittedException - if the current user lacks permissions to create new users
      InvalidSessionException
      RemoteException - if a user with the given username cannot be found
    • removeUser

      boolean removeUser(String token, String username) throws RemoteException
      Removes a user with the given username
      Parameters:
      token - The token identifying the current user
      username - The username of the user to be removed
      Returns:
      True if successful, false otherwise
      Throws:
      InvalidSessionException
      NotPermittedException - if the current user lacks the permission to remove users
      RemoteException - if the given username cannot be found
      RemoteException - if the user has authored content
    • editUser

      boolean editUser(String token, RemoteUser remoteUser) throws RemoteException
      Edits a user with the values in the given RemoteUser object

      Currently this will only update the user's full name and email

      Parameters:
      token - The token identifying the current user
      remoteUser - The object containing the user information
      Throws:
      NotPermittedException - if the current user cannot administer users or is not the actual user
      InvalidSessionException
      RemoteException - if a user with the given username cannot be found
      Since:
      2.0
    • deactivateUser

      boolean deactivateUser(String token, String username) throws RemoteException
      Deactivates the given user
      Parameters:
      token - The token identifying the current user
      username - The username of the user to deactivate
      Returns:
      True if the user was successfully deactivated, false otherwise
      Throws:
      NotPermittedException - if the current user does not have permissions to perform the action
      InvalidSessionException
      RemoteException - if the given username cannot be found
      RemoteException - if the user has already been deactivated
      Since:
      2.0
    • reactivateUser

      boolean reactivateUser(String token, String username) throws RemoteException
      Reactivates the given user
      Parameters:
      token - The token identifying the current user
      username - The username of the user to reactivate
      Returns:
      True if the user was successfully reactivated, false otherwise
      Throws:
      NotPermittedException - if the current user does not have permissions to perform the action
      InvalidSessionException
      RemoteException - if the given username cannot be found
      RemoteException - if the user is already active
      Since:
      2.0
    • isActiveUser

      boolean isActiveUser(String token, String username) throws RemoteException
      Checks if a given user is active.
      Parameters:
      username - The username to check
      Returns:
      True if the user is active or does not exist, false otherwise.
      Throws:
      RemoteException - If the username does not exist
    • getActiveUsers

      String[] getActiveUsers(String token, boolean viewAll) throws RemoteException
      Returns a list of the current system users
      Parameters:
      token - The token identifying the current user
      viewAll - Whether all users should be shown. When it is false, all users in the default users group will be returned. Otherwise, every registered user is returned.
      Returns:
      An array of usernames as Strings
      Throws:
      NotPermittedException - if the current user does not have administration permissions
      InvalidSessionException
      RemoteException
      Since:
      2.0
    • setUserInformation

      boolean setUserInformation(String token, RemoteUserInformation userInfo) throws RemoteException
      Updates a user's information

      Currently this will only update a user's "description", stored in the 'content' attribute

      Parameters:
      token - The token identifying the current user
      userInfo - A RemoteUserInformation object, containing the username, email, fullname, url and information
      Throws:
      NotPermittedException - if the current user cannot administer users or is not the actual user
      InvalidSessionException
      RemoteException - if there was an error saving the personal information
      Since:
      2.0
    • getUserInformation

      RemoteUserInformation getUserInformation(String token, String username) throws RemoteException
      Retrieves a user's information
      Parameters:
      token - The token identifying the current user
      username - The name of the user to get information on
      Throws:
      InvalidSessionException
      RemoteException - if a user with the given username cannot be found
      Since:
      2.0
    • changeMyPassword

      boolean changeMyPassword(String token, String oldPass, String newPass) throws RemoteException
      Change the current user's password
      Parameters:
      token - The token identifying the current user
      oldPass - The old password of the user, required for security purposes
      newPass - The new password for the user
      Throws:
      NotPermittedException - if newPass was incorrect
      InvalidSessionException
      RemoteException - if oldPass does not match the user's password
      RemoteException - if newPass is null or an empty String
      RemoteException - if there are problems setting the password in the UserAccessor
      Since:
      2.0
    • changeUserPassword

      boolean changeUserPassword(String token, String username, String newPass) throws RemoteException
      Change a user's password
      Parameters:
      token - The token identifying the current user
      username - The username of the user we are changing the password for
      newPass - The new password for the user
      Throws:
      NotPermittedException - if the current user does not have permission to administer the user
      InvalidSessionException
      RemoteException - if the user cannot be found
      RemoteException - if newPass is null or an empty String
      RemoteException - if there are problems setting the password in the UserAccessor
      Since:
      2.0
    • addProfilePicture

      boolean addProfilePicture(String token, String userName, String fileName, String mimeType, byte[] pictureData) throws RemoteException
      Add a profile picture to a user's profile
      Parameters:
      userName - The user name of the profile
      fileName - File name of the picture
      mimeType - Image mime type (must be from image/*)
      pictureData - The image data
      Returns:
      true if successful
      Throws:
      NotPermittedException - Principal is not permitted to add pictures to the specified profile
      InvalidSessionException
      RemoteException - if the user can not be found
      RemoteException - if the mimeType is not from image/*
      RemoteException - if the image can not be processed
      Since:
      2.2
    • renameUser

      boolean renameUser(String token, String oldUsername, String newUsername) throws RemoteException
      Change user's username
      Parameters:
      token - The token identifying the current user
      oldUsername - current username of the user
      newUsername - new username of the user
      Returns:
      true if successful
      Throws:
      NotPermittedException - if the current user does not have permissions to perform the action
      InvalidSessionException
      RemoteException - if the new username does not meet username requirements
      RemoteException - if the user could not be renamed
      Since:
      5.2
    • renameUsers

      String[] renameUsers(String token, Map<String,String> oldUsernamesToNewUsernames) throws RemoteException
      Change usernames for a set of users
      Parameters:
      token - The token identifying the current user
      oldUsernamesToNewUsernames - mapping of current usernames to new usernames of users
      Returns:
      empty array if the operation was successful or usernames of users that could not be renamed
      Throws:
      NotPermittedException - if the current user does not have permissions to perform the action
      InvalidSessionException
      RemoteException - if a new username does not meet username requirements
      RemoteException - if a user could not be renamed
      Since:
      5.2
    • getLabelsById

      RemoteLabel[] getLabelsById(String token, long objectId) throws RemoteException
      Returns all labels for the given ContentEntityObject ID.
      Parameters:
      token - The token identifying the current user
      objectId - The ID of the ContentEntityObject the method will retrieve the labels for
      Returns:
      An array of RemoteLabel objects
      Throws:
      RemoteException - if the object cannot be retrieved from the ContentEntityManager
      RemoteException - if the given user does not have VIEW permissions for the object
      Since:
      2.0
    • getMostPopularLabels

      RemoteLabel[] getMostPopularLabels(String token, int maxCount) throws RemoteException
      Returns the most popular labels for the Confluence instance, with a specified maximum number of results.
      Parameters:
      token - The token identifying the current user
      maxCount - The maximum number of labels to return. A maxCount of 0 means there is no limit.
      Returns:
      An array of RemoteLabel objects, sorted by descending popularity
      Throws:
      RemoteException
      Since:
      2.0
    • getMostPopularLabelsInSpace

      RemoteLabel[] getMostPopularLabelsInSpace(String token, String spaceKey, int maxCount) throws RemoteException
      Returns the most popular labels for the given spaceKey, with a specified maximum number of results.
      Parameters:
      token - The token identifying the current user
      spaceKey - The key of the space to limit the labels to
      maxCount - The maximum number of labels to return. A maxCount of 0 means there is no limit.
      Returns:
      An array of RemoteLabel objects, sorted by descending popularity
      Throws:
      RemoteException - if the space cannot be retrieved from the SpaceManager
      NotPermittedException - if the given user does not have VIEW permissions for the space
      Since:
      2.0
    • getRecentlyUsedLabels

      RemoteLabel[] getRecentlyUsedLabels(String token, int maxResults) throws RemoteException
      Returns the recently used labels for the Confluence instance, with a specified maximum number of results.
      Parameters:
      token - The token identifying the current user
      maxResults - The maximum number of labels to return. A value of 0 means the default is used.
      Returns:
      An array of RemoteLabel objects, sorted by most recent use
      Throws:
      RemoteException
      Since:
      2.0
    • getRecentlyUsedLabelsInSpace

      RemoteLabel[] getRecentlyUsedLabelsInSpace(String token, String spaceKey, int maxResults) throws RemoteException
      Returns the recently used labels for the given spaceKey, with a specified maximum number of results.
      Parameters:
      token - The token identifying the current user
      spaceKey - The key of the space to limit the labels to
      maxResults - The maximum number of labels to return. A value of 0 means the default is used.
      Returns:
      An array of RemoteLabel objects, sorted by most recent use
      Throws:
      RemoteException - if the space does not exist, or the user lacks permission to view it
      NotPermittedException - if the given user does not have VIEW permissions for the space
      Since:
      2.0
    • getSpacesWithLabel

      RemoteSpace[] getSpacesWithLabel(String token, String labelName) throws RemoteException
      Returns an array of Spaces that have been labelled with labelName
      Parameters:
      token - The token identifying the current user
      labelName - The name of the label (namespace prefixes permitted)
      Returns:
      An array of RemoteSpace instances
      Throws:
      InvalidSessionException
      RemoteException - if labelName is an empty string or null
      RemoteException - if labelName contains an invalid namespace prefix
      RemoteException - if a label named labelName cannot be found
      Since:
      2.0
    • getRelatedLabels

      RemoteLabel[] getRelatedLabels(String token, String labelName, int maxResults) throws RemoteException
      Returns the labels related to the given label name, with a specified maximum number of results.
      Parameters:
      token - The token identifying the current user
      labelName - The name of the label (namespace prefixes permitted)
      maxResults - The maximum number of labels to return. A value of 0 means the default is used.
      Returns:
      An array of RemoteLabel objects (sorted by frequency of use)
      Throws:
      RemoteException - if labelName is an empty string or null
      RemoteException - if labelName contains an invalid namespace prefix
      RemoteException - if a label named labelName cannot be found
      Since:
      2.0
    • getRelatedLabelsInSpace

      RemoteLabel[] getRelatedLabelsInSpace(String token, String labelName, String spaceKey, int maxResults) throws RemoteException
      Returns the labels related to the given label name for the given spaceKey, with a specified maximum number of results.
      Parameters:
      token - The token identifying the current user
      labelName - The name of the label (namespace prefixes permitted)
      spaceKey - The key of the space to limit the labels to
      maxResults - The maximum number of labels to return. A maxCount of 0 means the default is used.
      Returns:
      An array of RemoteLabel objects (sorted by frequency of use)
      Throws:
      RemoteException - if labelName is an empty string or null
      RemoteException - if labelName contains an invalid namespace prefix
      RemoteException - if a label named labelName cannot be found
      RemoteException - if the Space does not exist, or the user does not have VIEW permissions
      Since:
      2.0
    • getLabelsByDetail

      RemoteLabel[] getLabelsByDetail(String token, String labelName, String namespace, String spaceKey, String owner) throws RemoteException
      Retrieves the labels matching the given labelName, namespace or owner.

      This method can be used to retrieve labels of a specfic type, such as personal labels, by setting the namespace.

      Parameters with empty strings are ignored.

      Parameters:
      token - the authentication token for the user
      labelName - the name of the label to search for (not parsed for prefixes)
      namespace - the namespace to restrict by
      spaceKey - the key of the space to restrict by
      owner - the owner of the labels
      Returns:
      an array of matching RemoteLabel objects
      Throws:
      InvalidSessionException
      RemoteException - if labelName is an empty string or null
      RemoteException - if labelName contains an invalid namespace prefix
      RemoteException - if a label named labelName cannot be found
      RemoteException - if the Space does not exist, or the user does not have VIEW permissions
      RemoteException - if the owner is not a valid user
      Since:
      2.0
      See Also:
    • getLabelContentById

      RemoteSearchResult[] getLabelContentById(String token, long labelId) throws RemoteException
      Returns the content for a given label ID
      Parameters:
      token - The token identifying the current user
      labelId - The ID of the label
      Returns:
      An array of RemoteSearchResult objects
      Throws:
      RemoteException - if a Label could not be retrieved for the given ID
      Since:
      2.0
    • getLabelContentByName

      RemoteSearchResult[] getLabelContentByName(String token, String labelName) throws RemoteException
      Returns the content for a given label name
      Parameters:
      token - The token identifying the current user
      labelName - The name of a label (namespace prefixes permitted)
      Returns:
      An array of RemoteSearchResult objects
      Throws:
      RemoteException - if the label name is null
      RemoteException - if the label name is an empty String
      RemoteException - if a Label could not be retrieved for the given ID
      Since:
      2.0
    • getLabelContentByObject

      RemoteSearchResult[] getLabelContentByObject(String token, RemoteLabel labelObject) throws RemoteException
      Returns the content for a given label object
      Parameters:
      token - The token identifying the current user
      labelObject - The RemoteLabel object
      Returns:
      An array of RemoteSearchResult objects
      Throws:
      RemoteException - if the RemoteLabel object is null
      RemoteException - if a Label could not be retrieved for the given ID
      Since:
      2.0
    • getSpacesContainingContentWithLabel

      RemoteSpace[] getSpacesContainingContentWithLabel(String token, String labelName) throws RemoteException
      Returns all Spaces that have content labelled with labelName
      Parameters:
      token - The token identifying the current user
      labelName - The label to retrieve the content for (namespace prefixes permitted)
      Returns:
      An array of RemoteSpace instances (order undefined)
      Throws:
      InvalidSessionException
      RemoteException - if labelName is an empty string or null
      RemoteException - if labelName contains an invalid namespace prefix
      RemoteException - if a label named labelName cannot be found
      Since:
      2.0
    • addLabelByName

      boolean addLabelByName(String token, String labelName, long objectId) throws RemoteException
      Adds a label to the object with the given ContentEntityObject ID.
      Parameters:
      token - The token identifying the current user
      labelName - The name of the label(s) to be added to the ContentEntityObject, in the form of a space-separated string
      objectId - The ID of the ContentEntityObject the method will act on
      Returns:
      True if successfully added, false otherwise.
      Throws:
      RemoteException - if the label name is null or an empty String
      RemoteException - if the split label name is invalid (as determined by LabelUtil.split())
      RemoteException - if the object was not valid
      RemoteException - if the user does not have VIEW permissions for the object
      RemoteException - if the label could not be created
      NotPermittedException - if the user lacks EDIT permissions for the object
      Since:
      2.0
    • addLabelById

      boolean addLabelById(String token, long labelId, long objectId) throws RemoteException
      Adds a label with the given ID to the object with the given ContentEntityObject ID.
      Parameters:
      token - The token identifying the current user
      labelId - The ID of the label to be added to the ContentEntityObject
      objectId - The ID of the ContentEntityObject the method will act on
      Returns:
      True if successfully added, false otherwise.
      Throws:
      RemoteException - if a Label could not be retrieved for the given ID
      RemoteException - if the object was not valid
      RemoteException - if the user lacks VIEW permissions for the object
      NotPermittedException - if the user lacks EDIT permissions for the object
      Since:
      2.0
    • addLabelByObject

      boolean addLabelByObject(String token, RemoteLabel labelObject, long objectId) throws RemoteException
      Adds the given label object to the object with the given ContentEntityObject ID.
      Parameters:
      token - The token identifying the current user
      labelObject - The label to be added to the ContentEntityObject
      objectId - The ID of the ContentEntityObject the method will act on
      Returns:
      True if successfully added, false otherwise.
      Throws:
      RemoteException - if the given RemoteLabel object is null
      RemoteException - if a Label could not be retrieved for the given ID
      RemoteException - if the object was not valid
      RemoteException - if the user lacks VIEW permissions for the object
      NotPermittedException - if the user lacks EDIT permissions for the object
      Since:
      2.0
    • addLabelByNameToSpace

      boolean addLabelByNameToSpace(String token, String labelName, String spaceKey) throws RemoteException
      Adds a label to the object with the given ContentEntityObject ID.
      Parameters:
      token - The token identifying the current user
      labelName - The name of the label(s) to be added to the Space, in the form of a space-separated string
      spaceKey - The Space to add the label to
      Returns:
      True if successfully added, false otherwise.
      Throws:
      RemoteException - if the label name is null or an empty String
      RemoteException - if the split label name is invalid (as determined by LabelUtil.split())
      RemoteException - if the space does not exist, or the user does not have VIEW permissions
      RemoteException - if the label could not be created
      NotPermittedException - if the user does not have permission to add the label
      Since:
      2.0
    • removeLabelByName

      boolean removeLabelByName(String token, String labelName, long objectId) throws RemoteException
      Removes the given label from the object with the given ContentEntityObject ID.
      Parameters:
      token - The token identifying the current user
      labelName - The name of the label(s) to be removed from the ContentEntityObject, in the form of a space-separated String
      objectId - The ID of the ContentEntityObject the method will act on
      Returns:
      True if successfully removed, false otherwise.
      Throws:
      RemoteException - if the label name is null
      RemoteException - if the label name is an empty String
      RemoteException - if one of the given label names does not exist (occurs before removing labels)
      RemoteException - if the object was not valid
      RemoteException - if the user lacks VIEW permissions for the object
      NotPermittedException - if the user lacks EDIT permissions for the object
      Since:
      2.0
    • removeLabelById

      boolean removeLabelById(String token, long labelId, long objectId) throws RemoteException
      Removes the label with the given ID from the object with the given ContentEntityObject ID.
      Parameters:
      token - The token identifying the current user
      labelId - The ID of the label to be removed from the ContentEntityObject
      objectId - The ID of the ContentEntityObject the method will act on
      Returns:
      True if successfully removed, false otherwise.
      Throws:
      RemoteException - if a Label could not be retrieved for the given ID
      RemoteException - if the object was not valid
      RemoteException - if the user lacks VIEW permissions for the object
      NotPermittedException - if the user lacks EDIT permissions for the object
      Since:
      2.0
    • removeLabelByObject

      boolean removeLabelByObject(String token, RemoteLabel labelObject, long objectId) throws RemoteException
      Removes the given label object from the object with the given ContentEntityObject ID.
      Parameters:
      token - The token identifying the current user
      labelObject - The label to be removed from the ContentEntityObject
      objectId - The ID of the ContentEntityObject the method will act on
      Returns:
      True if successfully removed, false otherwise.
      Throws:
      RemoteException - if the RemoteLabel object is null
      RemoteException - if a Label could not be retrieved for the given ID
      RemoteException - if the object was not valid
      RemoteException - if the user lacks VIEW permissions for the object
      NotPermittedException - if the user lacks EDIT permissions for the object
      Since:
      2.0
    • removeLabelByNameFromSpace

      boolean removeLabelByNameFromSpace(String token, String labelName, String spaceKey) throws RemoteException
      Removes the given label from the given Space
      Parameters:
      token - The token identifying the current user
      labelName - The name of the label(s) to be removed from the Space, in the form of a space-separated String
      spaceKey - The Space the method will act on
      Returns:
      True if successfully removed, false otherwise.
      Throws:
      RemoteException - if the label name is null
      RemoteException - if the label name is an empty String
      RemoteException - if one of the given label names does not exist (occurs before removing labels)
      RemoteException - if the space does not exist, or the user lacks VIEW permissions
      NotPermittedException - if the user lacks EDIT permissions for the Space
      Since:
      2.0
    • getContentPermissionSets

      RemoteContentPermissionSet[] getContentPermissionSets(String token, long contentId) throws RemoteException
      Get the content permission sets for a particular piece of content
      Parameters:
      token - the login token for the current user
      contentId - the content ID of the content to be looked up
      Returns:
      an array of the permission sets applied to that content
      Throws:
      NotPermittedException - if the content can not be found, or can not be accessed by the current user
      InvalidSessionException - if no login session can be found for the supplied token
      RemoteException - if something random goes wrong
    • getContentPermissionSet

      RemoteContentPermissionSet getContentPermissionSet(String token, long contentId, String permissionType) throws RemoteException
      Get the content permission set of a certain type for a particular piece of content
      Parameters:
      token - the login token for the current user
      contentId - the content ID of the content to be looked up
      permissionType - type of content permission
      Returns:
      a content permission set of the specified type on the content object to be looked up
      Throws:
      NotPermittedException - if the content can not be found, or can not be accessed by the current user
      InvalidSessionException - if no login session can be found for the supplied token
      RemoteException - if something random goes wrong
    • setContentPermissions

      boolean setContentPermissions(String token, long contentId, String permissionType, RemoteContentPermission[] remoteContentPermissions) throws RemoteException
      Set the content permissions for a particular permission type on some content. These permissions will replace any permissions that already exist for that permission type.
      Parameters:
      token - the login token
      contentId - the id of the content to have permissions set on it
      permissionType - the type of the permissions (one of the constants from ContentPermission)
      remoteContentPermissions - the permissions to set
      Returns:
      true (because RPC methods can't be void)
      Throws:
      NotPermittedException - if the content can not be found or can not be accessed by the current user
      InvalidSessionException - if no login session can be found for the supplied token
      RemoteException - if something random goes wrong
    • addGlobalPermission

      boolean addGlobalPermission(String token, String permission, String remoteEntityName) throws RemoteException
      Add global permissions for a user or group
      Parameters:
      token - the login token
      permission - the Space Permission to add
      remoteEntityName - the name of the user or group
      Returns:
      True if successful, false otherwise
      Throws:
      NotPermittedException - if the user lacks permissions to perform the action
      RemoteException
    • addGlobalPermissions

      boolean addGlobalPermissions(String token, String[] permissions, String remoteEntityName) throws RemoteException
      Add a global permission for a user or group
      Parameters:
      token - the login token
      permissions - Array of permissions to add
      remoteEntityName - the name of the user or group
      Returns:
      True if successful, false otherwise
      Throws:
      NotPermittedException - if the user lacks permissions to perform the action
      RemoteException
    • removeGlobalPermission

      boolean removeGlobalPermission(String token, String permission, String remoteEntityName) throws RemoteException
      Remove a global permission
      Parameters:
      token - the login token
      permission - the Space Permission to add
      remoteEntityName - the name of the user or group
      Returns:
      True if successful, false otherwise
      Throws:
      NotPermittedException - if the user lacks permissions to perform the action
      RemoteException
    • addAnonymousUsePermission

      boolean addAnonymousUsePermission(String token) throws RemoteException
      Throws:
      RemoteException
    • removeAnonymousUsePermission

      boolean removeAnonymousUsePermission(String token) throws RemoteException
      Remove anonymous use permission. If the anonymous user also has 'view user profile' permission then this will also be removed.
      Parameters:
      token - the login token
      Returns:
      true if successful, false otherwise.
      Throws:
      RemoteException
    • addAnonymousViewUserProfilePermission

      boolean addAnonymousViewUserProfilePermission(String token) throws RemoteException
      This permission can only be set if the anonymous user already has 'use' permission. If this is not the case then false will be returned.
      Parameters:
      token - the login token
      Returns:
      true if successfully set; otherwise false.
      Throws:
      RemoteException
    • removeAnonymousViewUserProfilePermission

      boolean removeAnonymousViewUserProfilePermission(String token) throws RemoteException
      Throws:
      RemoteException
    • setEnableAnonymousAccess

      boolean setEnableAnonymousAccess(String token, boolean value) throws RemoteException
      Throws:
      RemoteException
    • isPluginEnabled

      boolean isPluginEnabled(String token, String pluginKey) throws RemoteException
      Returns true if the specified plugin is enabled.
      Throws:
      RemoteException
    • isPluginInstalled

      boolean isPluginInstalled(String token, String pluginKey) throws RemoteException
      Returns true if the specified plugin is installed.
      Throws:
      RemoteException
    • installPlugin

      boolean installPlugin(String token, String pluginFileName, byte[] pluginData) throws RemoteException
      Installs a plugin.
      Parameters:
      pluginFileName - the original filename of the plugin. It should end with the correct file extension .xml or .jar.
      pluginData - a byte[] containing the contents of the plugin xml or jar file.
      Throws:
      RemoteException
    • isDarkFeatureEnabled

      boolean isDarkFeatureEnabled(String token, String key) throws RemoteException
      Throws:
      RemoteException
    • startActivity

      boolean startActivity(String token, String key, String user) throws RemoteException
      Call startActivity on the heartbeat manager bean
      Parameters:
      token - rpc authentication token
      key - the activity key to start
      user - the username of the user starting the activity
      Returns:
      true if executes startActivity without error.
      Throws:
      RemoteException
    • stopActivity

      boolean stopActivity(String token, String key, String user) throws RemoteException
      Call stopActivity on the heartbeat manager bean
      Parameters:
      token - rpc authentication token
      key - the activity key to stop
      user - the username of the user stopping the activity
      Returns:
      true if executes stopActivity without error.
      Throws:
      RemoteException
    • refreshIndex

      default boolean refreshIndex(String token)
      Refresh the index immediately, which publishes its most recent changes and makes them available for searching. This method is only applicable to the OpenSearch platform.
      Parameters:
      token - rpc authentication token