com.atlassian.confluence.rest.client

Interface RemoteRelationService

All Known Implementing Classes:

RemoteRelationServiceImpl

@ExperimentalApi
public interface RemoteRelationService

Relation service, which allows to manage relations between entities. "Relations" are used when it's needed to mark related content. Good examples of relations are Watches (when user marks certain pages as watchable), Likes (user marks content as "Liked") or Favourites (content is marked as favourite by user) (all are "user2content" type of relations).

For example, to create a favourite relation between a user and the DEV Space :

      relationService.create(RelationInstance.builder(user, new SpaceFavouriteRelation(), space).build));
 assertTrue(relationService.isRelated(user, new SpaceFavouriteRelation(), space));
     
 

and to find the favourite spaces of a user :

      relationService.findTargets(user, new SpaceFavouriteRelation()).fetchMany(new SimplePageRequest(0, 10));
 

Since:

5.9

See Also:

RelationInstance, Relatable, RelationDescriptor

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	RemoteRelationService.RelatableFinder<R extends Relatable> Finder, which is used to perform basic relation operations, such as fetching source or target entities of particular relation, get total number of related entities etc.
static interface	RemoteRelationService.RemoteParameterRelationFinder<S extends Relatable,T extends Relatable>
static interface	RemoteRelationService.RemoteRelationFetcher<S extends Relatable,T extends Relatable>
static interface	RemoteRelationService.RemoteRelationFinder<S extends Relatable,T extends Relatable>

Method Summary

Modifier and Type	Method and Description
<S extends Relatable,T extends Relatable> com.atlassian.util.concurrent.Promise<Void>	create(RelationInstance<S,T> relationInstance) Creates a directed relation between two relatable entities.
<S extends Relatable,T extends Relatable> com.atlassian.util.concurrent.Promise<Void>	delete(RelationInstance<S,T> relationInstance) Remove a relation if it exists between a source and a target relatable entity
<S extends Relatable,T extends Relatable> RemoteRelationService.RemoteRelationFinder<S,T>	find(Expansion... expansions)
<S extends Relatable,T extends Relatable> RemoteRelationService.RelatableFinder<S>	findSources(T target, RelationDescriptor<S,T> relationDescriptor) Find relation instances to the given target entity that have a relation with the relation name from the source type
<S extends Relatable,T extends Relatable> RemoteRelationService.RelatableFinder<S>	findTargets(S source, RelationDescriptor<S,T> relationDescriptor) Find relation instances of the given target type that have a relation with the relation name from the source entity.
<S extends Relatable,T extends Relatable> com.atlassian.util.concurrent.Promise<Boolean>	isRelated(S source, RelationDescriptor<S,T> relationDescriptor, T target) Determine whether a given source and target are related by the given relation

Method Detail

create

<S extends Relatable,T extends Relatable> com.atlassian.util.concurrent.Promise<Void> create(RelationInstance<S,T> relationInstance)
                                                                                      throws ServiceException

Creates a directed relation between two relatable entities.

For example, when a user favourites a space a SpaceFavouriteRelation is created from the user to the space:

      relationService.create(RelationInstance.builder(user, new SpaceFavouriteRelation(), space).build));
 

Type Parameters:

S - type of the source entity

T - type of the target entity

Parameters:

relationInstance - the relation to create

Returns:

the newly created relationInstance

Throws:

ServiceException - if validation fails

delete

<S extends Relatable,T extends Relatable> com.atlassian.util.concurrent.Promise<Void> delete(RelationInstance<S,T> relationInstance)
                                                                                      throws ServiceException

Remove a relation if it exists between a source and a target relatable entity

Type Parameters:

S - type of the source entity

T - type of the target entity

Parameters:

relationInstance - relation to be deleted

Throws:

ServiceException - if validation fails

isRelated

<S extends Relatable,T extends Relatable> com.atlassian.util.concurrent.Promise<Boolean> isRelated(S source,
                                                                                                   RelationDescriptor<S,T> relationDescriptor,
                                                                                                   T target)

Determine whether a given source and target are related by the given relation

Type Parameters:

S - type of the source entity

T - type of the target entity

Returns:

true if the relation exists between the given source and target

findSources

<S extends Relatable,T extends Relatable> RemoteRelationService.RelatableFinder<S> findSources(T target,
                                                                                               RelationDescriptor<S,T> relationDescriptor)

Find relation instances to the given target entity that have a relation with the relation name from the source type

Type Parameters:

S - type of the source entity

T - type of the target entity

Parameters:

target - target entity instance

relationDescriptor - relation descriptor

Returns:

sources for the relation

findTargets

<S extends Relatable,T extends Relatable> RemoteRelationService.RelatableFinder<S> findTargets(S source,
                                                                                               RelationDescriptor<S,T> relationDescriptor)

Find relation instances of the given target type that have a relation with the relation name from the source entity.

Type Parameters:

S - type of the source entity

T - type of the target entity

Parameters:

source - source entity instance

relationDescriptor - relation descriptor

Returns:

targets for the relation

find

<S extends Relatable,T extends Relatable> RemoteRelationService.RemoteRelationFinder<S,T> find(Expansion... expansions)