Package org.dspace.content

Class RelationshipServiceImpl

java.lang.Object

org.dspace.content.RelationshipServiceImpl

All Implemented Interfaces:

RelationshipService, DSpaceCRUDService<Relationship>

public class RelationshipServiceImpl
extends Object
implements RelationshipService

Field Summary

Fields

Modifier and Type	Field	Description
protected AuthorizeService	authorizeService
protected ItemService	itemService
protected RelationshipDAO	relationshipDAO
protected RelationshipTypeService	relationshipTypeService

Constructor Summary

Constructors

Constructor	Description
RelationshipServiceImpl()

Method Summary

Modifier and Type	Method	Description
int	countByItem(Context context, Item item)	This method returns a count of Relationship objects that have the given Item object as a leftItem or a rightItem
int	countByItem(Context context, Item item, boolean excludeTilted, boolean excludeNonLatest)	This method returns a count of Relationship objects that have the given Item object as a leftItem or a rightItem
int	countByItemAndRelationshipType(Context context, Item item, RelationshipType relationshipType, boolean isLeft)	Count total number of relationships (rows in relationship table) by a relationship type and a boolean indicating whether the relationship should contain the item on the left side or not NOTE: tilted relationships are NEVER excluded when fetching one relationship type
int	countByItemAndRelationshipType(Context context, Item item, RelationshipType relationshipType, boolean isLeft, boolean excludeNonLatest)	Count total number of relationships (rows in relationship table) by a relationship type and a boolean indicating whether the relationship should contain the item on the left side or not NOTE: tilted relationships are NEVER excluded when fetching one relationship type
int	countByItemRelationshipTypeAndRelatedList(Context context, UUID focusUUID, RelationshipType relationshipType, List<UUID> items, boolean isLeft)	Count total number of relationships that match focusItem on the one hand and matches list of related items elsewhere.
int	countByRelationshipType(Context context, RelationshipType relationshipType)	Count total number of relationships (rows in relationship table) by a relationship type NOTE: tilted relationships are NEVER excluded when fetching one relationship type
int	countByTypeName(Context context, String typeName)	Count total number of relationships (rows in relationship table) by a relationship leftward or rightward typeName
int	countTotal(Context context)	counts all relationships
Relationship	create(Context context)
Relationship	create(Context c, Item leftItem, Item rightItem, RelationshipType relationshipType, int leftPlace, int rightPlace)	This method is used to construct a Relationship object with all it's variables, except the leftward label, rightward label and latest version status
Relationship	create(Context c, Item leftItem, Item rightItem, RelationshipType relationshipType, int leftPlace, int rightPlace, String leftwardValue, String rightwardValue)	This method is used to construct a Relationship object with all it's variables, except the latest version status
Relationship	create(Context c, Item leftItem, Item rightItem, RelationshipType relationshipType, int leftPlace, int rightPlace, String leftwardValue, String rightwardValue, Relationship.LatestVersionStatus latestVersionStatus)	This method is used to construct a Relationship object with all it's variables
Relationship	create(Context context, Relationship relationship)	This method creates a relationship object in the database equal to the given relationship param if this is a valid relationship
void	delete(Context context, Relationship relationship)
void	delete(Context context, Relationship relationship, boolean copyToLeftItem, boolean copyToRightItem)	This method is used to delete a Relationship whilst given the possibility to copy the Virtual Metadata created by this relationship to the left and/or right item
Relationship	find(Context context, int id)
List<Relationship>	findAll(Context context)	Retrieves the full list of relationships currently in the system
List<Relationship>	findAll(Context context, Integer limit, Integer offset)	Retrieves the full list of relationships currently in the system
List<Relationship>	findByItem(Context context, Item item)	Retrieves the list of Relationships currently in the system for which the given Item is either a leftItem or a rightItem object
List<Relationship>	findByItem(Context context, Item item, Integer limit, Integer offset, boolean excludeTilted)	Retrieves the list of Relationships currently in the system for which the given Item is either a leftItem or a rightItem object
List<Relationship>	findByItem(Context context, Item item, Integer limit, Integer offset, boolean excludeTilted, boolean excludeNonLatest)	Retrieves the list of Relationships currently in the system for which the given Item is either a leftItem or a rightItem object
List<Relationship>	findByItemAndRelationshipType(Context context, Item item, RelationshipType relationshipType)	This method returns a list of Relationships for which the leftItem or rightItem is equal to the given Item object and for which the RelationshipType object is equal to the relationshipType property NOTE: tilted relationships are NEVER excluded when fetching one relationship type
List<Relationship>	findByItemAndRelationshipType(Context context, Item item, RelationshipType relationshipType, boolean isLeft)
List<Relationship>	findByItemAndRelationshipType(Context context, Item item, RelationshipType relationshipType, boolean isLeft, int limit, int offset)	This method returns a list of Relationships for which the leftItem or rightItem is equal to the given Item object and for which the RelationshipType object is equal to the relationshipType property NOTE: tilted relationships are NEVER excluded when fetching one relationship type
List<Relationship>	findByItemAndRelationshipType(Context context, Item item, RelationshipType relationshipType, boolean isLeft, int limit, int offset, boolean excludeNonLatest)	This method returns a list of Relationships for which the leftItem or rightItem is equal to the given Item object and for which the RelationshipType object is equal to the relationshipType property NOTE: tilted relationships are NEVER excluded when fetching one relationship type
List<Relationship>	findByItemAndRelationshipType(Context context, Item item, RelationshipType relationshipType, int limit, int offset)	This method returns a list of Relationships for which the leftItem or rightItem is equal to the given Item object and for which the RelationshipType object is equal to the relationshipType property NOTE: tilted relationships are NEVER excluded when fetching one relationship type
List<Relationship>	findByItemAndRelationshipType(Context context, Item item, RelationshipType relationshipType, int limit, int offset, boolean excludeNonLatest)	This method returns a list of Relationships for which the leftItem or rightItem is equal to the given Item object and for which the RelationshipType object is equal to the relationshipType property NOTE: tilted relationships are NEVER excluded when fetching one relationship type
List<Relationship>	findByItemRelationshipTypeAndRelatedList(Context context, UUID focusUUID, RelationshipType relationshipType, List<UUID> items, boolean isLeft, int offset, int limit)	This method is used to retrieve relationships that match focusItem on the one hand and matches list of related items elsewhere.
List<ItemUuidAndRelationshipId>	findByLatestItemAndRelationshipType(Context context, Item latestItem, RelationshipType relationshipType, boolean isLeft)	This method returns the UUIDs of all items that have a relationship with the given item, from the perspective of the other item.
List<Relationship>	findByRelationshipType(Context context, RelationshipType relationshipType)	This method returns a list of Relationship objects for which the relationshipType property is equal to the given RelationshipType object NOTE: tilted relationships are NEVER excluded when fetching one relationship type
List<Relationship>	findByRelationshipType(Context context, RelationshipType relationshipType, Integer limit, Integer offset)	This method returns a list of Relationship objets for which the relationshipType property is equal to the given RelationshipType object NOTE: tilted relationships are NEVER excluded when fetching one relationship type
List<Relationship>	findByTypeName(Context context, String typeName)	This method returns a list of Relationship objects for the given typeName
List<Relationship>	findByTypeName(Context context, String typeName, Integer limit, Integer offset)	This method returns a list of Relationship objects for the given typeName
void	forceDelete(Context context, Relationship relationship, boolean copyToLeftItem, boolean copyToRightItem)	This method is used to delete a Relationship whilst given the possibility to copy the Virtual Metadata created by this relationship to the left and/or right item.
Relationship	move(Context context, Relationship relationship, Integer newLeftPlace, Integer newRightPlace)	Move the given relationship to a new leftPlace and/or rightPlace.
Relationship	move(Context context, Relationship relationship, Item newLeftItem, Item newRightItem)	Move the given relationship to a new leftItem and/or rightItem.
void	update(Context context, List<Relationship> relationships)	Persist a collection of model objects.
void	update(Context context, Relationship relationship)	Persist a model object.
void	updateItem(Context context, Item relatedItem)	This method will update the given item's metadata order.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

relationshipDAO

@Autowired(required=true)
protected RelationshipDAO relationshipDAO

authorizeService

@Autowired(required=true)
protected AuthorizeService authorizeService

itemService

@Autowired(required=true)
protected ItemService itemService

relationshipTypeService

@Autowired(required=true)
protected RelationshipTypeService relationshipTypeService

Constructor Detail

RelationshipServiceImpl

public RelationshipServiceImpl()

Method Detail

create

public Relationship create(Context context)
                    throws SQLException,
                           AuthorizeException

Specified by:

create in interface DSpaceCRUDService<Relationship>

Throws:

SQLException

AuthorizeException

create

public Relationship create(Context c,
                           Item leftItem,
                           Item rightItem,
                           RelationshipType relationshipType,
                           int leftPlace,
                           int rightPlace)
                    throws AuthorizeException,
                           SQLException

Description copied from interface: RelationshipService

This method is used to construct a Relationship object with all it's variables, except the leftward label, rightward label and latest version status

Specified by:

create in interface RelationshipService

Parameters:

c - The relevant DSpace context

leftItem - The leftItem Item object for the relationship

rightItem - The rightItem Item object for the relationship

relationshipType - The RelationshipType object for the relationship

leftPlace - The leftPlace integer for the relationship

rightPlace - The rightPlace integer for the relationship

Returns:

The created Relationship object with the given properties

Throws:

AuthorizeException - If something goes wrong

SQLException - If something goes wrong

create

public Relationship create(Context c,
                           Item leftItem,
                           Item rightItem,
                           RelationshipType relationshipType,
                           int leftPlace,
                           int rightPlace,
                           String leftwardValue,
                           String rightwardValue,
                           Relationship.LatestVersionStatus latestVersionStatus)
                    throws AuthorizeException,
                           SQLException

Description copied from interface: RelationshipService

This method is used to construct a Relationship object with all it's variables

Specified by:

create in interface RelationshipService

Parameters:

c - The relevant DSpace context

leftItem - The leftItem Item object for the relationship

rightItem - The rightItem Item object for the relationship

relationshipType - The RelationshipType object for the relationship

leftPlace - The leftPlace integer for the relationship

rightPlace - The rightPlace integer for the relationship

leftwardValue - The leftwardValue string for the relationship

rightwardValue - The rightwardValue string for the relationship

latestVersionStatus - The latestVersionStatus value for the relationship

Returns:

The created Relationship object with the given properties

Throws:

AuthorizeException - If something goes wrong

SQLException - If something goes wrong

create

public Relationship create(Context c,
                           Item leftItem,
                           Item rightItem,
                           RelationshipType relationshipType,
                           int leftPlace,
                           int rightPlace,
                           String leftwardValue,
                           String rightwardValue)
                    throws AuthorizeException,
                           SQLException

Description copied from interface: RelationshipService

This method is used to construct a Relationship object with all it's variables, except the latest version status

Specified by:

create in interface RelationshipService

Parameters:

c - The relevant DSpace context

leftItem - The leftItem Item object for the relationship

rightItem - The rightItem Item object for the relationship

relationshipType - The RelationshipType object for the relationship

leftPlace - The leftPlace integer for the relationship

rightPlace - The rightPlace integer for the relationship

leftwardValue - The leftwardValue string for the relationship

rightwardValue - The rightwardValue string for the relationship

Returns:

The created Relationship object with the given properties

Throws:

AuthorizeException - If something goes wrong

SQLException - If something goes wrong

create

public Relationship create(Context context,
                           Relationship relationship)
                    throws SQLException,
                           AuthorizeException

Description copied from interface: RelationshipService

This method creates a relationship object in the database equal to the given relationship param if this is a valid relationship

Specified by:

create in interface RelationshipService

Parameters:

context - The relevant DSpace context

relationship - The relationship that will be created in the database if it is valid

Returns:

The created relationship with updated place variables

Throws:

SQLException - If something goes wrong

AuthorizeException - If something goes wrong with authorizations

move

public Relationship move(Context context,
                         Relationship relationship,
                         Integer newLeftPlace,
                         Integer newRightPlace)
                  throws SQLException,
                         AuthorizeException

Description copied from interface: RelationshipService

Move the given relationship to a new leftPlace and/or rightPlace. This will 1. verify whether the move is authorized 2. move the relationship to the specified left/right place 3. update the left/right place of other relationships and/or metadata in order to resolve the move without leaving any gaps At least one of the new places should be non-null, otherwise no changes will be made.

Specified by:

move in interface RelationshipService

Parameters:

context - The relevant DSpace context

relationship - The Relationship to move

newLeftPlace - The value to set the leftPlace of this Relationship to

newRightPlace - The value to set the rightPlace of this Relationship to

Returns:

The moved relationship with updated place variables

Throws:

SQLException - If something goes wrong

AuthorizeException - If the user is not authorized to update the Relationship or its Items

move

public Relationship move(Context context,
                         Relationship relationship,
                         Item newLeftItem,
                         Item newRightItem)
                  throws SQLException,
                         AuthorizeException

Description copied from interface: RelationshipService

Move the given relationship to a new leftItem and/or rightItem. This will 1. move the relationship to the last place in its current left or right Item. This ensures that we don't leave any gaps when moving the relationship to a new Item. If only one of the relationship's Items is changed,the order of relationships and metadatain the other will not be affected 2. insert the relationship into the new Item(s) At least one of the new Items should be non-null, otherwise no changes will be made.

Specified by:

move in interface RelationshipService

Parameters:

context - The relevant DSpace context

relationship - The Relationship to move

newLeftItem - The value to set the leftItem of this Relationship to

newRightItem - The value to set the rightItem of this Relationship to

Returns:

The moved relationship with updated left/right Items variables

Throws:

SQLException - If something goes wrong

AuthorizeException - If the user is not authorized to update the Relationship or its Items

updateItem

public void updateItem(Context context,
                       Item relatedItem)
                throws SQLException,
                       AuthorizeException

Description copied from interface: RelationshipService

This method will update the given item's metadata order. If the relationships for the item have been modified and will calculate the place based on a metadata field, this function will ensure the place is calculated.

Specified by:

updateItem in interface RelationshipService

Parameters:

context - The relevant DSpace context

relatedItem - The Item for which the list of Relationship location is calculated based on a metadata field

Throws:

SQLException - If something goes wrong

AuthorizeException - If the user is not authorized to update the item

find

public Relationship find(Context context,
                         int id)
                  throws SQLException

Specified by:

find in interface DSpaceCRUDService<Relationship>

Throws:

SQLException

findByItem

public List<Relationship> findByItem(Context context,
                                     Item item)
                              throws SQLException

Description copied from interface: RelationshipService

Retrieves the list of Relationships currently in the system for which the given Item is either a leftItem or a rightItem object

Specified by:

findByItem in interface RelationshipService

Parameters:

context - The relevant DSpace context

item - The Item that has to be the left or right item for the relationship to be included in the list

Returns:

The list of relationships for which each relationship adheres to the above listed constraint

Throws:

SQLException - If something goes wrong

findByItem

public List<Relationship> findByItem(Context context,
                                     Item item,
                                     Integer limit,
                                     Integer offset,
                                     boolean excludeTilted)
                              throws SQLException

Description copied from interface: RelationshipService

Retrieves the list of Relationships currently in the system for which the given Item is either a leftItem or a rightItem object

Specified by:

findByItem in interface RelationshipService

Parameters:

context - The relevant DSpace context

item - The Item that has to be the left or right item for the relationship to be included in the list

limit - paging limit

offset - paging offset

excludeTilted - If true, excludes tilted relationships

Returns:

The list of relationships for which each relationship adheres to the above listed constraint

Throws:

SQLException - If something goes wrong

findByItem

public List<Relationship> findByItem(Context context,
                                     Item item,
                                     Integer limit,
                                     Integer offset,
                                     boolean excludeTilted,
                                     boolean excludeNonLatest)
                              throws SQLException

Description copied from interface: RelationshipService

Retrieves the list of Relationships currently in the system for which the given Item is either a leftItem or a rightItem object

Specified by:

findByItem in interface RelationshipService

Parameters:

context - The relevant DSpace context

item - The Item that has to be the left or right item for the relationship to be included in the list

limit - paging limit

offset - paging offset

excludeTilted - If true, excludes tilted relationships

excludeNonLatest - If true, excludes all relationships for which the other item has a more recent version that is relevant for this relationship

Returns:

The list of relationships for which each relationship adheres to the above listed constraint

Throws:

SQLException - If something goes wrong

findAll

public List<Relationship> findAll(Context context)
                           throws SQLException

Description copied from interface: RelationshipService

Retrieves the full list of relationships currently in the system

Specified by:

findAll in interface RelationshipService

Parameters:

context - The relevant DSpace context

Returns:

The list of all relationships currently in the system

Throws:

SQLException - If something goes wrong

findAll

public List<Relationship> findAll(Context context,
                                  Integer limit,
                                  Integer offset)
                           throws SQLException

Description copied from interface: RelationshipService

Retrieves the full list of relationships currently in the system

Specified by:

findAll in interface RelationshipService

Parameters:

context - The relevant DSpace context

limit - paging limit

offset - paging offset

Returns:

The list of all relationships currently in the system

Throws:

SQLException - If something goes wrong

update

public void update(Context context,
                   Relationship relationship)
            throws SQLException,
                   AuthorizeException

Description copied from interface: DSpaceCRUDService

Persist a model object.

Specified by:

update in interface DSpaceCRUDService<Relationship>

relationship - object to be persisted.

Throws:

SQLException - passed through.

AuthorizeException - passed through.

update

public void update(Context context,
                   List<Relationship> relationships)
            throws SQLException,
                   AuthorizeException

Description copied from interface: DSpaceCRUDService

Persist a collection of model objects.

Specified by:

update in interface DSpaceCRUDService<Relationship>

relationships - object to be persisted.

Throws:

SQLException - passed through.

AuthorizeException - passed through.

delete

public void delete(Context context,
                   Relationship relationship)
            throws SQLException,
                   AuthorizeException

Specified by:

delete in interface DSpaceCRUDService<Relationship>

Throws:

SQLException

AuthorizeException

delete

public void delete(Context context,
                   Relationship relationship,
                   boolean copyToLeftItem,
                   boolean copyToRightItem)
            throws SQLException,
                   AuthorizeException

Description copied from interface: RelationshipService

This method is used to delete a Relationship whilst given the possibility to copy the Virtual Metadata created by this relationship to the left and/or right item

Specified by:

delete in interface RelationshipService

Parameters:

context - The relevant DSpace context

relationship - The relationship to be deleted

copyToLeftItem - A boolean indicating whether we should copy metadata to the left item or not

copyToRightItem - A boolean indicating whether we should copy metadata to the right item or not

Throws:

SQLException

AuthorizeException

forceDelete

public void forceDelete(Context context,
                        Relationship relationship,
                        boolean copyToLeftItem,
                        boolean copyToRightItem)
                 throws SQLException,
                        AuthorizeException

Description copied from interface: RelationshipService

This method is used to delete a Relationship whilst given the possibility to copy the Virtual Metadata created by this relationship to the left and/or right item. This method will bypass the cardinality checks on the RelationshipType for the given Relationship This should only be used during the deletion of items so that the min cardinality check can't disallow items to be deleted

Specified by:

forceDelete in interface RelationshipService

Parameters:

context - The relevant DSpace context

relationship - The relationship to be deleted

copyToLeftItem - A boolean indicating whether we should copy metadata to the left item or not

copyToRightItem - A boolean indicating whether we should copy metadata to the right item or not

Throws:

SQLException

AuthorizeException

findByItemAndRelationshipType

public List<Relationship> findByItemAndRelationshipType(Context context,
                                                        Item item,
                                                        RelationshipType relationshipType,
                                                        boolean isLeft)
                                                 throws SQLException

Throws:

SQLException

findByItemAndRelationshipType

public List<Relationship> findByItemAndRelationshipType(Context context,
                                                        Item item,
                                                        RelationshipType relationshipType)
                                                 throws SQLException

Description copied from interface: RelationshipService

This method returns a list of Relationships for which the leftItem or rightItem is equal to the given Item object and for which the RelationshipType object is equal to the relationshipType property NOTE: tilted relationships are NEVER excluded when fetching one relationship type

Specified by:

findByItemAndRelationshipType in interface RelationshipService

Parameters:

context - The relevant DSpace context

item - The Item object to be matched on the leftItem or rightItem for the relationship

relationshipType - The RelationshipType object that will be used to check the Relationship on

Returns:

The list of Relationship objects that have the given Item object as leftItem or rightItem and for which the relationshipType property is equal to the given RelationshipType

Throws:

SQLException - If something goes wrong

findByItemAndRelationshipType

public List<Relationship> findByItemAndRelationshipType(Context context,
                                                        Item item,
                                                        RelationshipType relationshipType,
                                                        int limit,
                                                        int offset)
                                                 throws SQLException

Description copied from interface: RelationshipService

This method returns a list of Relationships for which the leftItem or rightItem is equal to the given Item object and for which the RelationshipType object is equal to the relationshipType property NOTE: tilted relationships are NEVER excluded when fetching one relationship type

Specified by:

findByItemAndRelationshipType in interface RelationshipService

Parameters:

context - The relevant DSpace context

item - The Item object to be matched on the leftItem or rightItem for the relationship

relationshipType - The RelationshipType object that will be used to check the Relationship on

Returns:

The list of Relationship objects that have the given Item object as leftItem or rightItem and for which the relationshipType property is equal to the given RelationshipType

Throws:

SQLException - If something goes wrong

findByItemAndRelationshipType

public List<Relationship> findByItemAndRelationshipType(Context context,
                                                        Item item,
                                                        RelationshipType relationshipType,
                                                        int limit,
                                                        int offset,
                                                        boolean excludeNonLatest)
                                                 throws SQLException

Description copied from interface: RelationshipService

This method returns a list of Relationships for which the leftItem or rightItem is equal to the given Item object and for which the RelationshipType object is equal to the relationshipType property NOTE: tilted relationships are NEVER excluded when fetching one relationship type

Specified by:

findByItemAndRelationshipType in interface RelationshipService

Parameters:

context - The relevant DSpace context

item - The Item object to be matched on the leftItem or rightItem for the relationship

relationshipType - The RelationshipType object that will be used to check the Relationship on

excludeNonLatest - If true, excludes all relationships for which the other item has a more recent version that is relevant for this relationship

Returns:

The list of Relationship objects that have the given Item object as leftItem or rightItem and for which the relationshipType property is equal to the given RelationshipType

Throws:

SQLException - If something goes wrong

findByItemAndRelationshipType

public List<Relationship> findByItemAndRelationshipType(Context context,
                                                        Item item,
                                                        RelationshipType relationshipType,
                                                        boolean isLeft,
                                                        int limit,
                                                        int offset)
                                                 throws SQLException

Description copied from interface: RelationshipService

This method returns a list of Relationships for which the leftItem or rightItem is equal to the given Item object and for which the RelationshipType object is equal to the relationshipType property NOTE: tilted relationships are NEVER excluded when fetching one relationship type

Specified by:

findByItemAndRelationshipType in interface RelationshipService

Parameters:

context - The relevant DSpace context

item - The Item object to be matched on the leftItem or rightItem for the relationship

relationshipType - The RelationshipType object that will be used to check the Relationship on

isLeft - Is the item left or right

Returns:

The list of Relationship objects that have the given Item object as leftItem or rightItem and for which the relationshipType property is equal to the given RelationshipType

Throws:

SQLException - If something goes wrong

findByItemAndRelationshipType

public List<Relationship> findByItemAndRelationshipType(Context context,
                                                        Item item,
                                                        RelationshipType relationshipType,
                                                        boolean isLeft,
                                                        int limit,
                                                        int offset,
                                                        boolean excludeNonLatest)
                                                 throws SQLException

Description copied from interface: RelationshipService

This method returns a list of Relationships for which the leftItem or rightItem is equal to the given Item object and for which the RelationshipType object is equal to the relationshipType property NOTE: tilted relationships are NEVER excluded when fetching one relationship type

Specified by:

findByItemAndRelationshipType in interface RelationshipService

Parameters:

context - The relevant DSpace context

item - The Item object to be matched on the leftItem or rightItem for the relationship

relationshipType - The RelationshipType object that will be used to check the Relationship on

isLeft - Is the item left or right

excludeNonLatest - If true, excludes all relationships for which the other item has a more recent version that is relevant for this relationship

Returns:

The list of Relationship objects that have the given Item object as leftItem or rightItem and for which the relationshipType property is equal to the given RelationshipType

Throws:

SQLException - If something goes wrong

findByLatestItemAndRelationshipType

public List<ItemUuidAndRelationshipId> findByLatestItemAndRelationshipType(Context context,
                                                                           Item latestItem,
                                                                           RelationshipType relationshipType,
                                                                           boolean isLeft)
                                                                    throws SQLException

Description copied from interface: RelationshipService

This method returns the UUIDs of all items that have a relationship with the given item, from the perspective of the other item. In other words, given a relationship with the given item, the given item should have "latest status" in order for the other item uuid to be returned. This method differs from the "excludeNonLatest" property in other methods, because in this method the current item should have "latest status" to return the other item, whereas with "excludeNonLatest" the other item should have "latest status" to be returned. This method is used to index items in solr; when searching for related items of one of the returned uuids, the given item should appear as a search result. NOTE: This method does not return Relationships for performance, because doing so would eagerly fetch the items on both sides, which is unnecessary. NOTE: tilted relationships are NEVER excluded when fetching one relationship type.

Specified by:

findByLatestItemAndRelationshipType in interface RelationshipService

Parameters:

context - the DSpace context.

latestItem - the target item; only relationships where this item has "latest status" should be considered.

relationshipType - the relationship type for which relationships should be selected.

isLeft - whether the entity type of the item occurs on the left or right side of the relationship type. This is redundant in most cases, but necessary because relationship types my have the same entity type on both sides.

Returns:

a list containing pairs of relationship ids and item uuids.

Throws:

SQLException - if something goes wrong.

findByRelationshipType

public List<Relationship> findByRelationshipType(Context context,
                                                 RelationshipType relationshipType)
                                          throws SQLException

Description copied from interface: RelationshipService

This method returns a list of Relationship objects for which the relationshipType property is equal to the given RelationshipType object NOTE: tilted relationships are NEVER excluded when fetching one relationship type

Specified by:

findByRelationshipType in interface RelationshipService

Parameters:

context - The relevant DSpace context

relationshipType - The RelationshipType object that will be used to check the Relationship on

Returns:

The list of Relationship objects for which the given RelationshipType object is equal to the relationshipType property

Throws:

SQLException - If something goes wrong

findByRelationshipType

public List<Relationship> findByRelationshipType(Context context,
                                                 RelationshipType relationshipType,
                                                 Integer limit,
                                                 Integer offset)
                                          throws SQLException

Description copied from interface: RelationshipService

This method returns a list of Relationship objets for which the relationshipType property is equal to the given RelationshipType object NOTE: tilted relationships are NEVER excluded when fetching one relationship type

Specified by:

findByRelationshipType in interface RelationshipService

Parameters:

context - The relevant DSpace context

relationshipType - The RelationshipType object that will be used to check the Relationship on

limit - paging limit

offset - paging offset

Returns:

The list of Relationship objects for which the given RelationshipType object is equal to the relationshipType property

Throws:

SQLException - If something goes wrong

findByTypeName

public List<Relationship> findByTypeName(Context context,
                                         String typeName)
                                  throws SQLException

Description copied from interface: RelationshipService

This method returns a list of Relationship objects for the given typeName

Specified by:

findByTypeName in interface RelationshipService

Parameters:

context - The relevant DSpace context

typeName - The leftward or rightward typeName of the relationship type

Returns:

A list of Relationship objects that have the given RelationshipType object as the relationshipType property

Throws:

SQLException - If something goes wrong

findByTypeName

public List<Relationship> findByTypeName(Context context,
                                         String typeName,
                                         Integer limit,
                                         Integer offset)
                                  throws SQLException

Description copied from interface: RelationshipService

This method returns a list of Relationship objects for the given typeName

Specified by:

findByTypeName in interface RelationshipService

Parameters:

context - The relevant DSpace context

typeName - The leftward or rightward typeName of the relationship type

limit - paging limit

offset - paging offset

Returns:

A list of Relationship objects that have the given RelationshipType object as the relationshipType property

Throws:

SQLException - If something goes wrong

countTotal

public int countTotal(Context context)
               throws SQLException

Description copied from interface: RelationshipService

counts all relationships

Specified by:

countTotal in interface RelationshipService

Parameters:

context - DSpace context object

Returns:

total relationships

Throws:

SQLException - if database error

countByItem

public int countByItem(Context context,
                       Item item)
                throws SQLException

Description copied from interface: RelationshipService

This method returns a count of Relationship objects that have the given Item object as a leftItem or a rightItem

Specified by:

countByItem in interface RelationshipService

Parameters:

context - The relevant DSpace context

item - The item that should be either a leftItem or a rightItem of all the Relationship objects in the returned list

Returns:

The list of Relationship objects that contain either a left or a right item that is equal to the given item

Throws:

SQLException - If something goes wrong

countByItem

public int countByItem(Context context,
                       Item item,
                       boolean excludeTilted,
                       boolean excludeNonLatest)
                throws SQLException

Description copied from interface: RelationshipService

This method returns a count of Relationship objects that have the given Item object as a leftItem or a rightItem

Specified by:

countByItem in interface RelationshipService

Parameters:

context - The relevant DSpace context

item - The item that should be either a leftItem or a rightItem of all the Relationship objects in the returned list

excludeTilted - if true, excludes tilted relationships

excludeNonLatest - if true, exclude relationships for which the opposite item is not the latest version that is relevant

Returns:

The list of Relationship objects that contain either a left or a right item that is equal to the given item

Throws:

SQLException - If something goes wrong

countByRelationshipType

public int countByRelationshipType(Context context,
                                   RelationshipType relationshipType)
                            throws SQLException

Description copied from interface: RelationshipService

Count total number of relationships (rows in relationship table) by a relationship type NOTE: tilted relationships are NEVER excluded when fetching one relationship type

Specified by:

countByRelationshipType in interface RelationshipService

Parameters:

context - context

relationshipType - relationship type to filter by

Returns:

total count

Throws:

SQLException - if database error

countByItemAndRelationshipType

public int countByItemAndRelationshipType(Context context,
                                          Item item,
                                          RelationshipType relationshipType,
                                          boolean isLeft)
                                   throws SQLException

Description copied from interface: RelationshipService

Count total number of relationships (rows in relationship table) by a relationship type and a boolean indicating whether the relationship should contain the item on the left side or not NOTE: tilted relationships are NEVER excluded when fetching one relationship type

Specified by:

countByItemAndRelationshipType in interface RelationshipService

Parameters:

context - context

relationshipType - relationship type to filter by

isLeft - Indicating whether the counted Relationships should have the given Item on the left side or not

Returns:

total count with the given parameters

Throws:

SQLException - if database error

countByItemAndRelationshipType

public int countByItemAndRelationshipType(Context context,
                                          Item item,
                                          RelationshipType relationshipType,
                                          boolean isLeft,
                                          boolean excludeNonLatest)
                                   throws SQLException

Description copied from interface: RelationshipService

Count total number of relationships (rows in relationship table) by a relationship type and a boolean indicating whether the relationship should contain the item on the left side or not NOTE: tilted relationships are NEVER excluded when fetching one relationship type

Specified by:

countByItemAndRelationshipType in interface RelationshipService

Parameters:

context - context

relationshipType - relationship type to filter by

isLeft - Indicating whether the counted Relationships should have the given Item on the left side

excludeNonLatest - If true, excludes all relationships for which the other item has a more recent version that is relevant for this relationship

Returns:

total count with the given parameters

Throws:

SQLException - if database error

countByTypeName

public int countByTypeName(Context context,
                           String typeName)
                    throws SQLException

Description copied from interface: RelationshipService

Count total number of relationships (rows in relationship table) by a relationship leftward or rightward typeName

Specified by:

countByTypeName in interface RelationshipService

Parameters:

context - context

typeName - typeName of relationship

Returns:

total count

Throws:

SQLException - if database error

findByItemRelationshipTypeAndRelatedList

public List<Relationship> findByItemRelationshipTypeAndRelatedList(Context context,
                                                                   UUID focusUUID,
                                                                   RelationshipType relationshipType,
                                                                   List<UUID> items,
                                                                   boolean isLeft,
                                                                   int offset,
                                                                   int limit)
                                                            throws SQLException

Description copied from interface: RelationshipService

This method is used to retrieve relationships that match focusItem on the one hand and matches list of related items elsewhere.

Specified by:

findByItemRelationshipTypeAndRelatedList in interface RelationshipService

Parameters:

context - DSpace context object

focusUUID - UUID of Item that will match left side if the param isLeft is true otherwise right side

relationshipType - Relationship type to filter by

items - List of UUID that will use to filter other side respect the focusUUID

isLeft - Indicating whether the counted Relationships should have the given Item on the left side or not

offset - paging offset

limit - paging limit

Returns:

Throws:

SQLException - If database error

countByItemRelationshipTypeAndRelatedList

public int countByItemRelationshipTypeAndRelatedList(Context context,
                                                     UUID focusUUID,
                                                     RelationshipType relationshipType,
                                                     List<UUID> items,
                                                     boolean isLeft)
                                              throws SQLException

Description copied from interface: RelationshipService

Count total number of relationships that match focusItem on the one hand and matches list of related items elsewhere.

Specified by:

countByItemRelationshipTypeAndRelatedList in interface RelationshipService

Parameters:

context - DSpace context object

focusUUID - UUID of Item that will match left side if the param isLeft is true otherwise right side

relationshipType - Relationship type to filter by

items - List of UUID that will use to filter other side respect the focusUUID

isLeft - Indicating whether the counted Relationships should have the given Item on the left side or not

Returns:

Throws:

SQLException - If database error