won.protocol.repository

Interface ConnectionRepository

All Superinterfaces:

org.springframework.data.repository.CrudRepository<Connection,java.lang.Long>, org.springframework.data.repository.PagingAndSortingRepository<Connection,java.lang.Long>, org.springframework.data.repository.Repository<Connection,java.lang.Long>, WonRepository<Connection>

public interface ConnectionRepository
extends WonRepository<Connection>

Created with IntelliJ IDEA. User: Gabriel Date: 04.11.12 Time: 16:56 To change this template use File | Settings | File Templates.

Method Summary

Modifier and Type	Method and Description
java.util.List<Connection>	findByConnectionURI(java.net.URI URI)
java.util.List<Connection>	findByNeedURI(java.net.URI URI)
org.springframework.data.domain.Slice<Connection>	findByNeedURI(java.net.URI URI, org.springframework.data.domain.Pageable pageable)
java.util.List<Connection>	findByNeedURIAndRemoteNeedURI(java.net.URI needURI, java.net.URI remoteNeedURI)
java.util.List<Connection>	findByNeedURIAndRemoteNeedURIAndState(java.net.URI needURI, java.net.URI remoteNeedURI, ConnectionState connectionState)
java.util.List<Connection>	findByNeedURIAndStateAndTypeURI(java.net.URI needURI, ConnectionState connectionState, java.net.URI facetType)
java.util.List<java.net.URI>	findModifiedConnectionURIsAfter(java.util.Date modifiedAfter)
Connection	findOneByConnectionURI(java.net.URI URI)
Connection	findOneByConnectionURIAndVersionNot(java.net.URI URI, int version)
Connection	findOneByConnectionURIForUpdate(java.net.URI uri)
Connection	findOneByNeedURIAndRemoteNeedURIAndTypeURIForUpdate(java.net.URI needURI, java.net.URI remoteNeedURI, java.net.URI typeUri)
java.util.List<java.net.URI>	getAllConnectionURIs()
org.springframework.data.domain.Slice<java.net.URI>	getAllConnectionURIs(org.springframework.data.domain.Pageable pageable)
java.util.List<java.net.URI>	getAllConnectionURIsForNeedURI(java.net.URI needURI)
org.springframework.data.domain.Slice<java.net.URI>	getAllConnectionURIsForNeedURI(java.net.URI needURI, org.springframework.data.domain.Pageable pageable)
java.util.List<Connection>	getConnectionsByNeedURIAndNotInStateForUpdate(java.net.URI needURI, ConnectionState connectionState)
org.springframework.data.domain.Slice<java.net.URI>	getConnectionURIByActivityDate(java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<java.net.URI>	getConnectionURIByActivityDate(org.springframework.data.domain.Pageable pageable) Obtains connectionURIs grouped by the connectionURI itself and with message properties attached.
org.springframework.data.domain.Slice<java.net.URI>	getConnectionURIByActivityDate(java.net.URI needURI, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<java.net.URI>	getConnectionURIByActivityDate(java.net.URI needURI, org.springframework.data.domain.Pageable pageable) Obtains connectionURIs of the provided Need grouped by the connectionURI itself and with message properties attached.
org.springframework.data.domain.Slice<java.net.URI>	getConnectionURIByActivityDate(java.net.URI needURI, WonMessageType messageType, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<java.net.URI>	getConnectionURIByActivityDate(java.net.URI needURI, WonMessageType messageType, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<java.net.URI>	getConnectionURIsAfterByActivityDate(java.util.Date resumeEventDate, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<java.net.URI>	getConnectionURIsAfterByActivityDate(java.net.URI needURI, java.util.Date resumeEventDate, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<java.net.URI>	getConnectionURIsAfterByActivityDate(java.net.URI needURI, java.util.Date resumeEventDate, WonMessageType messageType, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<java.net.URI>	getConnectionURIsBeforeByActivityDate(java.util.Date resumeEventDate, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<java.net.URI>	getConnectionURIsBeforeByActivityDate(java.net.URI needURI, java.util.Date resumeEventDate, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<java.net.URI>	getConnectionURIsBeforeByActivityDate(java.net.URI needURI, java.util.Date resumeEventDate, WonMessageType messageType, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
java.util.List<java.net.URI>	getConnectionURIsByNeedURIAndNotInState(java.net.URI needURI, ConnectionState connectionState)

Methods inherited from interface won.protocol.repository.WonRepository

findById, saveAndFlush

Methods inherited from interface org.springframework.data.repository.PagingAndSortingRepository

findAll, findAll

Methods inherited from interface org.springframework.data.repository.CrudRepository

count, delete, delete, delete, deleteAll, exists, findAll, findAll, findOne, save, save

Method Detail

findByConnectionURI

java.util.List<Connection> findByConnectionURI(java.net.URI URI)

findOneByConnectionURI

Connection findOneByConnectionURI(java.net.URI URI)

findOneByConnectionURIForUpdate

@Lock(value=PESSIMISTIC_WRITE)
 @Query(value="select con from Connection con where connectionURI = :uri")
Connection findOneByConnectionURIForUpdate(@Param(value="uri")
                                                                                                                                                     java.net.URI uri)

findOneByConnectionURIAndVersionNot

Connection findOneByConnectionURIAndVersionNot(java.net.URI URI,
                                               int version)

findOneByNeedURIAndRemoteNeedURIAndTypeURIForUpdate

@Lock(value=PESSIMISTIC_WRITE)
 @Query(value="select con from Connection con where needURI = :needUri and remoteNeedURI = :remoteNeedUri and typeURI = :typeUri")
Connection findOneByNeedURIAndRemoteNeedURIAndTypeURIForUpdate(@Param(value="needUri")
                                                                                                                                                                                                                                 java.net.URI needURI,
                                                                                                                                                                                                                                 @Param(value="remoteNeedUri")
                                                                                                                                                                                                                                 java.net.URI remoteNeedURI,
                                                                                                                                                                                                                                 @Param(value="typeUri")
                                                                                                                                                                                                                                 java.net.URI typeUri)

findByNeedURI

java.util.List<Connection> findByNeedURI(java.net.URI URI)

findByNeedURI

org.springframework.data.domain.Slice<Connection> findByNeedURI(java.net.URI URI,
                                                                org.springframework.data.domain.Pageable pageable)

findByNeedURIAndRemoteNeedURI

java.util.List<Connection> findByNeedURIAndRemoteNeedURI(java.net.URI needURI,
                                                         java.net.URI remoteNeedURI)

findByNeedURIAndStateAndTypeURI

java.util.List<Connection> findByNeedURIAndStateAndTypeURI(java.net.URI needURI,
                                                           ConnectionState connectionState,
                                                           java.net.URI facetType)

findByNeedURIAndRemoteNeedURIAndState

java.util.List<Connection> findByNeedURIAndRemoteNeedURIAndState(java.net.URI needURI,
                                                                 java.net.URI remoteNeedURI,
                                                                 ConnectionState connectionState)

getAllConnectionURIs

@Query(value="select connectionURI from Connection")
java.util.List<java.net.URI> getAllConnectionURIs()

getAllConnectionURIs

@Query(value="select connectionURI from Connection")
org.springframework.data.domain.Slice<java.net.URI> getAllConnectionURIs(org.springframework.data.domain.Pageable pageable)

getAllConnectionURIsForNeedURI

@Query(value="select connectionURI from Connection where needURI = ?1")
java.util.List<java.net.URI> getAllConnectionURIsForNeedURI(java.net.URI needURI)

getAllConnectionURIsForNeedURI

@Query(value="select connectionURI from Connection where needURI = ?1")
org.springframework.data.domain.Slice<java.net.URI> getAllConnectionURIsForNeedURI(java.net.URI needURI,
                                                                                                                                                           org.springframework.data.domain.Pageable pageable)

getConnectionURIsByNeedURIAndNotInState

@Query(value="select connectionURI from Connection where needURI = ?1 and state != ?2")
java.util.List<java.net.URI> getConnectionURIsByNeedURIAndNotInState(java.net.URI needURI,
                                                                                                                                                             ConnectionState connectionState)

getConnectionsByNeedURIAndNotInStateForUpdate

@Lock(value=PESSIMISTIC_WRITE)
 @Query(value="select c from Connection c where c.needURI = ?1 and c.state != ?2")
java.util.List<Connection> getConnectionsByNeedURIAndNotInStateForUpdate(java.net.URI needURI,
                                                                                                                                                                                           ConnectionState connectionState)

findModifiedConnectionURIsAfter

@Query(value="select connectionURI from Connection where lastUpdate > :modifiedAfter")
java.util.List<java.net.URI> findModifiedConnectionURIsAfter(@Param(value="modifiedAfter")
                                                                                                                                                    java.util.Date modifiedAfter)

getConnectionURIByActivityDate

@Query(value="select msg.parentURI from MessageEventPlaceholder msg where (msg.senderURI = msg.parentURI or msg.receiverURI = msg.parentURI) group by msg.parentURI")
org.springframework.data.domain.Slice<java.net.URI> getConnectionURIByActivityDate(org.springframework.data.domain.Pageable pageable)

Obtains connectionURIs grouped by the connectionURI itself and with message properties attached. The paging request therefore can use criteria based on aggregated messages properties of the connection, such as min(msg.creationDate). For example: new PageRequest(0, 1, Sort.Direction.DESC, "min(msg.creationDate)"))

Parameters:

pageable -

Returns:

getConnectionURIByActivityDate

@Query(value="select msg.parentURI from MessageEventPlaceholder msg where ((msg.senderURI = msg.parentURI or msg.receiverURI = msg.parentURI) and (msg.creationDate < :referenceDate))group by msg.parentURI")
org.springframework.data.domain.Slice<java.net.URI> getConnectionURIByActivityDate(@Param(value="referenceDate")
                                                                                                                                                                                                                                                                                                  java.util.Date referenceDate,
                                                                                                                                                                                                                                                                                                  org.springframework.data.domain.Pageable pageable)

getConnectionURIsBeforeByActivityDate

@Query(value="select msg.parentURI from MessageEventPlaceholder msg where ((msg.senderURI = msg.parentURI or msg.receiverURI = msg.parentURI) and (msg.creationDate < :referenceDate))group by msg.parentURI having max(msg.creationDate) < :resumeDate")
org.springframework.data.domain.Slice<java.net.URI> getConnectionURIsBeforeByActivityDate(@Param(value="resumeDate")
                                                                                                                                                                                                                                                                                                                                                    java.util.Date resumeEventDate,
                                                                                                                                                                                                                                                                                                                                                    @Param(value="referenceDate")
                                                                                                                                                                                                                                                                                                                                                    java.util.Date referenceDate,
                                                                                                                                                                                                                                                                                                                                                    org.springframework.data.domain.Pageable pageable)

getConnectionURIsAfterByActivityDate

@Query(value="select msg.parentURI from MessageEventPlaceholder msg where ((msg.senderURI = msg.parentURI or msg.receiverURI = msg.parentURI) and (msg.creationDate < :referenceDate))group by msg.parentURI having max(msg.creationDate) > :resumeDate")
org.springframework.data.domain.Slice<java.net.URI> getConnectionURIsAfterByActivityDate(@Param(value="resumeDate")
                                                                                                                                                                                                                                                                                                                                                   java.util.Date resumeEventDate,
                                                                                                                                                                                                                                                                                                                                                   @Param(value="referenceDate")
                                                                                                                                                                                                                                                                                                                                                   java.util.Date referenceDate,
                                                                                                                                                                                                                                                                                                                                                   org.springframework.data.domain.Pageable pageable)

getConnectionURIByActivityDate

@Query(value="select msg.parentURI from MessageEventPlaceholder msg where (msg.senderNeedURI = :need and msg.senderURI = msg.parentURI)    or (msg.receiverNeedURI = :need and msg.receiverURI = msg.parentURI) group by msg.parentURI")
org.springframework.data.domain.Slice<java.net.URI> getConnectionURIByActivityDate(@Param(value="need")
                                                                                                                                                                                                                                                                                                                            java.net.URI needURI,
                                                                                                                                                                                                                                                                                                                            org.springframework.data.domain.Pageable pageable)

Obtains connectionURIs of the provided Need grouped by the connectionURI itself and with message properties attached. The paging request therefore can use criteria based on aggregated messages properties of the connection, such as min(msg.creationDate). For example: new PageRequest(0, 1, Sort.Direction.DESC, "min(msg.creationDate)"))

Parameters:

needURI -

pageable -

Returns:

getConnectionURIByActivityDate

@Query(value="select msg.parentURI from MessageEventPlaceholder msg where (((msg.senderNeedURI = :need and msg.senderURI = msg.parentURI)    or (msg.receiverNeedURI = :need and msg.receiverURI = msg.parentURI)) and (msg.creationDate < :referenceDate)) group by msg.parentURI")
org.springframework.data.domain.Slice<java.net.URI> getConnectionURIByActivityDate(@Param(value="need")
                                                                                                                                                                                                                                                                                                                                                                        java.net.URI needURI,
                                                                                                                                                                                                                                                                                                                                                                        @Param(value="referenceDate")
                                                                                                                                                                                                                                                                                                                                                                        java.util.Date referenceDate,
                                                                                                                                                                                                                                                                                                                                                                        org.springframework.data.domain.Pageable pageable)

getConnectionURIByActivityDate

@Query(value="select msg.parentURI from MessageEventPlaceholder msg where (((msg.senderNeedURI = :need and msg.senderURI = msg.parentURI)    or (msg.receiverNeedURI = :need and msg.receiverURI = msg.parentURI)) and (msg.creationDate < :referenceDate)   and (msg.messageType = :messageType)) group by msg.parentURI")
org.springframework.data.domain.Slice<java.net.URI> getConnectionURIByActivityDate(@Param(value="need")
                                                                                                                                                                                                                                                                                                                                                                                                               java.net.URI needURI,
                                                                                                                                                                                                                                                                                                                                                                                                               @Param(value="messageType")
                                                                                                                                                                                                                                                                                                                                                                                                               WonMessageType messageType,
                                                                                                                                                                                                                                                                                                                                                                                                               @Param(value="referenceDate")
                                                                                                                                                                                                                                                                                                                                                                                                               java.util.Date referenceDate,
                                                                                                                                                                                                                                                                                                                                                                                                               org.springframework.data.domain.Pageable pageable)

getConnectionURIByActivityDate

@Query(value="select msg.parentURI from MessageEventPlaceholder msg where (((msg.senderNeedURI = :need and msg.senderURI = msg.parentURI)    or (msg.receiverNeedURI = :need and msg.receiverURI = msg.parentURI))    and (msg.messageType = :messageType)) group by msg.parentURI")
org.springframework.data.domain.Slice<java.net.URI> getConnectionURIByActivityDate(@Param(value="need")
                                                                                                                                                                                                                                                                                                                                                                        java.net.URI needURI,
                                                                                                                                                                                                                                                                                                                                                                        @Param(value="messageType")
                                                                                                                                                                                                                                                                                                                                                                        WonMessageType messageType,
                                                                                                                                                                                                                                                                                                                                                                        org.springframework.data.domain.Pageable pageable)

getConnectionURIsBeforeByActivityDate

@Query(value="select msg.parentURI from MessageEventPlaceholder msg where (((msg.senderNeedURI = :need and msg.senderURI = msg.parentURI)    or (msg.receiverNeedURI = :need and msg.receiverURI = msg.parentURI)) and (msg.creationDate < :referenceDate))group by msg.parentURI having max(msg.creationDate) < :resumeDate")
org.springframework.data.domain.Slice<java.net.URI> getConnectionURIsBeforeByActivityDate(@Param(value="need")
                                                                                                                                                                                                                                                                                                                                                                                                                         java.net.URI needURI,
                                                                                                                                                                                                                                                                                                                                                                                                                         @Param(value="resumeDate")
                                                                                                                                                                                                                                                                                                                                                                                                                         java.util.Date resumeEventDate,
                                                                                                                                                                                                                                                                                                                                                                                                                         @Param(value="referenceDate")
                                                                                                                                                                                                                                                                                                                                                                                                                         java.util.Date referenceDate,
                                                                                                                                                                                                                                                                                                                                                                                                                         org.springframework.data.domain.Pageable pageable)

getConnectionURIsBeforeByActivityDate

@Query(value="select msg.parentURI from MessageEventPlaceholder msg where (((msg.senderNeedURI = :need and msg.senderURI = msg.parentURI) or (msg.receiverNeedURI = :need and msg.receiverURI = msg.parentURI))    and (msg.creationDate < :referenceDate) and (msg.messageType = :messageType))group by msg.parentURI having max(msg.creationDate) < :resumeDate")
org.springframework.data.domain.Slice<java.net.URI> getConnectionURIsBeforeByActivityDate(@Param(value="need")
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.net.URI needURI,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              @Param(value="resumeDate")
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.Date resumeEventDate,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              @Param(value="messageType")
                                                                                                                                                                                                                                                                                                                                                                                                                                                              WonMessageType messageType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              @Param(value="referenceDate")
                                                                                                                                                                                                                                                                                                                                                                                                                                                              java.util.Date referenceDate,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              org.springframework.data.domain.Pageable pageable)

getConnectionURIsAfterByActivityDate

@Query(value="select msg.parentURI from MessageEventPlaceholder msg where (((msg.senderNeedURI = :need and msg.senderURI = msg.parentURI)    or (msg.receiverNeedURI = :need and msg.receiverURI = msg.parentURI)) and (msg.creationDate < :referenceDate))group by msg.parentURI having max(msg.creationDate) > :resumeDate")
org.springframework.data.domain.Slice<java.net.URI> getConnectionURIsAfterByActivityDate(@Param(value="need")
                                                                                                                                                                                                                                                                                                                                                                                                                        java.net.URI needURI,
                                                                                                                                                                                                                                                                                                                                                                                                                        @Param(value="resumeDate")
                                                                                                                                                                                                                                                                                                                                                                                                                        java.util.Date resumeEventDate,
                                                                                                                                                                                                                                                                                                                                                                                                                        @Param(value="referenceDate")
                                                                                                                                                                                                                                                                                                                                                                                                                        java.util.Date referenceDate,
                                                                                                                                                                                                                                                                                                                                                                                                                        org.springframework.data.domain.Pageable pageable)

getConnectionURIsAfterByActivityDate

@Query(value="select msg.parentURI from MessageEventPlaceholder msg where (((msg.senderNeedURI = :need and msg.senderURI = msg.parentURI) or (msg.receiverNeedURI = :need and msg.receiverURI = msg.parentURI))    and (msg.creationDate < :referenceDate) and (msg.messageType = :messageType))group by msg.parentURI having max(msg.creationDate) > :resumeDate")
org.springframework.data.domain.Slice<java.net.URI> getConnectionURIsAfterByActivityDate(@Param(value="need")
                                                                                                                                                                                                                                                                                                                                                                                                                                                             java.net.URI needURI,
                                                                                                                                                                                                                                                                                                                                                                                                                                                             @Param(value="resumeDate")
                                                                                                                                                                                                                                                                                                                                                                                                                                                             java.util.Date resumeEventDate,
                                                                                                                                                                                                                                                                                                                                                                                                                                                             @Param(value="messageType")
                                                                                                                                                                                                                                                                                                                                                                                                                                                             WonMessageType messageType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                             @Param(value="referenceDate")
                                                                                                                                                                                                                                                                                                                                                                                                                                                             java.util.Date referenceDate,
                                                                                                                                                                                                                                                                                                                                                                                                                                                             org.springframework.data.domain.Pageable pageable)