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
long	countByAtomURIAndState(java.net.URI atomURI, ConnectionState connectionState)
long	countBySocketURIAndState(java.net.URI socketURI, ConnectionState connectionState)
long	countBySocketUriForUpdate(java.net.URI socketURI) Locks all connections for a given socket.
java.util.List<Connection>	findByAtomURI(java.net.URI URI)
java.util.List<Connection>	findByAtomURIAndNotState(java.net.URI atomURI, ConnectionState connectionState)
java.util.List<Connection>	findByAtomURIAndNotStateForUpdate(java.net.URI atomURI, ConnectionState connectionState)
java.util.List<Connection>	findByAtomURIAndSocketURIAndNotState(java.net.URI atomURI, java.net.URI socketURI, ConnectionState connectionState)
java.util.List<Connection>	findByAtomURIAndSocketURIAndNotStateForUpdate(java.net.URI atomURI, java.net.URI socketURI, ConnectionState connectionState)
java.util.List<Connection>	findByAtomURIAndState(java.net.URI atomURI, ConnectionState connectionState)
java.util.List<Connection>	findByAtomURIAndStateAndTypeURI(java.net.URI atomURI, ConnectionState connectionState, java.net.URI socketType)
java.util.List<Connection>	findByAtomURIAndTypeURI(java.net.URI atomURI, java.net.URI socketType)
java.util.List<Connection>	findByConnectionURI(java.net.URI URI)
java.util.List<Connection>	findBySocketURIAndState(java.net.URI socketURI, ConnectionState connectionState)
java.util.List<Connection>	findModifiedConnectionsAfter(java.util.Date modifiedAfter)
java.util.Optional<Connection>	findOneByAtomURIAndTargetAtomURIAndSocketURIAndNullTargetSocketForUpdate(java.net.URI atomURI, java.net.URI targetAtomURI, java.net.URI socketUri)
java.util.Optional<Connection>	findOneByAtomURIAndTargetAtomURIAndSocketURIAndTargetSocketURIForUpdate(java.net.URI atomURI, java.net.URI targetAtomURI, java.net.URI socketUri, java.net.URI targetSocketURI)
Connection	findOneByConnectionURI(java.net.URI URI)
Connection	findOneByConnectionURIAndVersionNot(java.net.URI URI, int version)
java.util.Optional<Connection>	findOneByConnectionURIForUpdate(java.net.URI uri)
java.util.List<Connection>	getAllConnections()
java.util.List<java.net.URI>	getAllConnectionURIs()
java.util.List<java.net.URI>	getAllConnectionURIsForAtomURI(java.net.URI atomURI)
org.springframework.data.domain.Slice<Connection>	getConnectionsAfterByActivityDate(java.util.Date resumeEventDate, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<Connection>	getConnectionsAfterByActivityDate(java.net.URI atomURI, java.util.Date resumeEventDate, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<Connection>	getConnectionsAfterByActivityDate(java.net.URI atomURI, java.util.Date resumeEventDate, WonMessageType messageType, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<Connection>	getConnectionsBeforeByActivityDate(java.util.Date resumeEventDate, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<Connection>	getConnectionsBeforeByActivityDate(java.net.URI atomURI, java.util.Date resumeEventDate, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<Connection>	getConnectionsBeforeByActivityDate(java.net.URI atomURI, java.util.Date resumeEventDate, WonMessageType messageType, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<Connection>	getConnectionsByActivityDate(java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<Connection>	getConnectionsByActivityDate(org.springframework.data.domain.Pageable pageable) Obtains connectionURIs grouped by the connectionURI itself and with message properties attached.
org.springframework.data.domain.Slice<Connection>	getConnectionsByActivityDate(java.net.URI atomURI, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<Connection>	getConnectionsByActivityDate(java.net.URI atomURI, org.springframework.data.domain.Pageable pageable) Obtains connections of the provided Atom grouped by the connectionURI itself and with message properties attached.
org.springframework.data.domain.Slice<Connection>	getConnectionsByActivityDate(java.net.URI atomURI, WonMessageType messageType, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<Connection>	getConnectionsByActivityDate(java.net.URI atomURI, WonMessageType messageType, org.springframework.data.domain.Pageable pageable)
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 atomURI, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<java.net.URI>	getConnectionURIByActivityDate(java.net.URI atomURI, org.springframework.data.domain.Pageable pageable) Obtains connectionURIs of the provided Atom grouped by the connectionURI itself and with message properties attached.
org.springframework.data.domain.Slice<java.net.URI>	getConnectionURIByActivityDate(java.net.URI atomURI, WonMessageType messageType, java.util.Date referenceDate, org.springframework.data.domain.Pageable pageable)
org.springframework.data.domain.Slice<java.net.URI>	getConnectionURIByActivityDate(java.net.URI atomURI, WonMessageType messageType, org.springframework.data.domain.Pageable pageable)

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")
java.util.Optional<Connection> findOneByConnectionURIForUpdate(@Param(value="uri")
                                                                                                                                                                         java.net.URI uri)

findOneByConnectionURIAndVersionNot

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

findOneByAtomURIAndTargetAtomURIAndSocketURIAndTargetSocketURIForUpdate

@Lock(value=PESSIMISTIC_WRITE)
 @Query(value="select con from Connection con where atomURI = :atomUri and targetAtomURI = :targetAtomUri and socketURI = :socketUri and targetSocketURI = :targetSocketUri")
java.util.Optional<Connection> findOneByAtomURIAndTargetAtomURIAndSocketURIAndTargetSocketURIForUpdate(@Param(value="atomUri")
                                                                                                                                                                                                                                                                                                                    java.net.URI atomURI,
                                                                                                                                                                                                                                                                                                                    @Param(value="targetAtomUri")
                                                                                                                                                                                                                                                                                                                    java.net.URI targetAtomURI,
                                                                                                                                                                                                                                                                                                                    @Param(value="socketUri")
                                                                                                                                                                                                                                                                                                                    java.net.URI socketUri,
                                                                                                                                                                                                                                                                                                                    @Param(value="targetSocketUri")
                                                                                                                                                                                                                                                                                                                    java.net.URI targetSocketURI)

findOneByAtomURIAndTargetAtomURIAndSocketURIAndNullTargetSocketForUpdate

@Lock(value=PESSIMISTIC_WRITE)
 @Query(value="select con from Connection con where atomURI = :atomUri and targetAtomURI = :targetAtomUri and socketURI = :socketUri and targetSocketURI is null")
java.util.Optional<Connection> findOneByAtomURIAndTargetAtomURIAndSocketURIAndNullTargetSocketForUpdate(@Param(value="atomUri")
                                                                                                                                                                                                                                                                                                          java.net.URI atomURI,
                                                                                                                                                                                                                                                                                                          @Param(value="targetAtomUri")
                                                                                                                                                                                                                                                                                                          java.net.URI targetAtomURI,
                                                                                                                                                                                                                                                                                                          @Param(value="socketUri")
                                                                                                                                                                                                                                                                                                          java.net.URI socketUri)

findByAtomURI

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

findByAtomURIAndStateAndTypeURI

java.util.List<Connection> findByAtomURIAndStateAndTypeURI(java.net.URI atomURI,
                                                           ConnectionState connectionState,
                                                           java.net.URI socketType)

findByAtomURIAndState

java.util.List<Connection> findByAtomURIAndState(java.net.URI atomURI,
                                                 ConnectionState connectionState)

findBySocketURIAndState

java.util.List<Connection> findBySocketURIAndState(java.net.URI socketURI,
                                                   ConnectionState connectionState)

findByAtomURIAndTypeURI

java.util.List<Connection> findByAtomURIAndTypeURI(java.net.URI atomURI,
                                                   java.net.URI socketType)

countBySocketUriForUpdate

@Lock(value=PESSIMISTIC_WRITE)
 @Query(value="select count (*) from Connection con where socketURI = :socketUri")
long countBySocketUriForUpdate(java.net.URI socketURI)

Locks all connections for a given socket. Used to avoid race conditions when deciding if socket capacity is exceeded.

countByAtomURIAndState

long countByAtomURIAndState(java.net.URI atomURI,
                            ConnectionState connectionState)

countBySocketURIAndState

long countBySocketURIAndState(java.net.URI socketURI,
                              ConnectionState connectionState)

getAllConnectionURIs

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

getAllConnections

@Query(value="select conn from Connection conn")
java.util.List<Connection> getAllConnections()

getAllConnectionURIsForAtomURI

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

findByAtomURIAndNotStateForUpdate

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

findByAtomURIAndNotState

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

findByAtomURIAndSocketURIAndNotStateForUpdate

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

findByAtomURIAndSocketURIAndNotState

@Query(value="select c from Connection c where c.atomURI = ?1 and c.socketURI = ?2 and c.state != ?3")
java.util.List<Connection> findByAtomURIAndSocketURIAndNotState(java.net.URI atomURI,
                                                                                                                                                                       java.net.URI socketURI,
                                                                                                                                                                       ConnectionState connectionState)

findModifiedConnectionsAfter

@Query(value="select conn from Connection conn where lastUpdate > :modifiedAfter")
java.util.List<Connection> findModifiedConnectionsAfter(@Param(value="modifiedAfter")
                                                                                                                                           java.util.Date modifiedAfter)

getConnectionURIByActivityDate

@Query(value="select msg.parentURI from MessageEventPlaceholder msg where (msg.senderURI = msg.parentURI or msg.recipientURI = 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:

getConnectionsByActivityDate

@Query(value="select conn from Connection conn where conn.connectionURI in (select distinct msg.parentURI from MessageEventPlaceholder msg where (msg.senderURI = msg.parentURI or msg.recipientURI = msg.parentURI))")
org.springframework.data.domain.Slice<Connection> getConnectionsByActivityDate(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.recipientURI = 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)

getConnectionsByActivityDate

@Query(value="select conn from Connection conn where conn.connectionURI in (select distinct msg.parentURI from MessageEventPlaceholder msg where ((msg.senderURI = msg.parentURI or msg.recipientURI = msg.parentURI) and (msg.creationDate < :referenceDate)))")
org.springframework.data.domain.Slice<Connection> getConnectionsByActivityDate(@Param(value="referenceDate")
                                                                                                                                                                                                                                                                                                                                                 java.util.Date referenceDate,
                                                                                                                                                                                                                                                                                                                                                 org.springframework.data.domain.Pageable pageable)

getConnectionsBeforeByActivityDate

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

getConnectionsAfterByActivityDate

@Query(value="select conn from Connection conn where conn.connectionURI in (select msg.parentURI from MessageEventPlaceholder msg where ((msg.senderURI = msg.parentURI or msg.recipientURI = msg.parentURI) and (msg.creationDate < :referenceDate))group by msg.parentURI having max(msg.creationDate) > :resumeDate)")
org.springframework.data.domain.Slice<Connection> getConnectionsAfterByActivityDate(@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.senderAtomURI = :atom and msg.senderURI = msg.parentURI)    or (msg.recipientAtomURI = :atom and msg.recipientURI = msg.parentURI) group by msg.parentURI")
org.springframework.data.domain.Slice<java.net.URI> getConnectionURIByActivityDate(@Param(value="atom")
                                                                                                                                                                                                                                                                                                                              java.net.URI atomURI,
                                                                                                                                                                                                                                                                                                                              org.springframework.data.domain.Pageable pageable)

Obtains connectionURIs of the provided Atom 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:

atomURI -

pageable -

Returns:

getConnectionsByActivityDate

@Query(value="select conn from Connection conn where conn.connectionURI in (select distinct msg.parentURI  from MessageEventPlaceholder msg where (msg.senderAtomURI = :atom and msg.senderURI = msg.parentURI)    or (msg.recipientAtomURI = :atom and msg.recipientURI = msg.parentURI))")
org.springframework.data.domain.Slice<Connection> getConnectionsByActivityDate(@Param(value="atom")
                                                                                                                                                                                                                                                                                                                                                                            java.net.URI atomURI,
                                                                                                                                                                                                                                                                                                                                                                            org.springframework.data.domain.Pageable pageable)

Obtains connections of the provided Atom 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:

atomURI -

pageable -

Returns:

getConnectionURIByActivityDate

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

getConnectionsByActivityDate

@Query(value="select conn from Connection conn where conn.connectionURI in (select distinct msg.parentURI  from MessageEventPlaceholder msg where (((msg.senderAtomURI = :atom and msg.senderURI = msg.parentURI)    or (msg.recipientAtomURI = :atom and msg.recipientURI = msg.parentURI)) and (msg.creationDate < :referenceDate)))")
org.springframework.data.domain.Slice<Connection> getConnectionsByActivityDate(@Param(value="atom")
                                                                                                                                                                                                                                                                                                                                                                                                                        java.net.URI atomURI,
                                                                                                                                                                                                                                                                                                                                                                                                                        @Param(value="referenceDate")
                                                                                                                                                                                                                                                                                                                                                                                                                        java.util.Date referenceDate,
                                                                                                                                                                                                                                                                                                                                                                                                                        org.springframework.data.domain.Pageable pageable)

getConnectionURIByActivityDate

@Query(value="select msg.parentURI from MessageEventPlaceholder msg where (((msg.senderAtomURI = :atom and msg.senderURI = msg.parentURI)    or (msg.recipientAtomURI = :atom and msg.recipientURI = 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="atom")
                                                                                                                                                                                                                                                                                                                                                                                                                 java.net.URI atomURI,
                                                                                                                                                                                                                                                                                                                                                                                                                 @Param(value="messageType")
                                                                                                                                                                                                                                                                                                                                                                                                                 WonMessageType messageType,
                                                                                                                                                                                                                                                                                                                                                                                                                 @Param(value="referenceDate")
                                                                                                                                                                                                                                                                                                                                                                                                                 java.util.Date referenceDate,
                                                                                                                                                                                                                                                                                                                                                                                                                 org.springframework.data.domain.Pageable pageable)

getConnectionsByActivityDate

@Query(value="select conn from Connection conn where conn.connectionURI in (select distinct msg.parentURI  from MessageEventPlaceholder msg where (((msg.senderAtomURI = :atom and msg.senderURI = msg.parentURI)    or (msg.recipientAtomURI = :atom and msg.recipientURI = msg.parentURI)) and (msg.creationDate < :referenceDate)   and (msg.messageType = :messageType)))")
org.springframework.data.domain.Slice<Connection> getConnectionsByActivityDate(@Param(value="atom")
                                                                                                                                                                                                                                                                                                                                                                                                                                                               java.net.URI atomURI,
                                                                                                                                                                                                                                                                                                                                                                                                                                                               @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.senderAtomURI = :atom and msg.senderURI = msg.parentURI)    or (msg.recipientAtomURI = :atom and msg.recipientURI = msg.parentURI))    and (msg.messageType = :messageType)) group by msg.parentURI")
org.springframework.data.domain.Slice<java.net.URI> getConnectionURIByActivityDate(@Param(value="atom")
                                                                                                                                                                                                                                                                                                                                                                          java.net.URI atomURI,
                                                                                                                                                                                                                                                                                                                                                                          @Param(value="messageType")
                                                                                                                                                                                                                                                                                                                                                                          WonMessageType messageType,
                                                                                                                                                                                                                                                                                                                                                                          org.springframework.data.domain.Pageable pageable)

getConnectionsByActivityDate

@Query(value="select conn from Connection conn where conn.connectionURI in (select distinct msg.parentURI  from MessageEventPlaceholder msg where (((msg.senderAtomURI = :atom and msg.senderURI = msg.parentURI)    or (msg.recipientAtomURI = :atom and msg.recipientURI = msg.parentURI))    and (msg.messageType = :messageType)))")
org.springframework.data.domain.Slice<Connection> getConnectionsByActivityDate(@Param(value="atom")
                                                                                                                                                                                                                                                                                                                                                                                                                        java.net.URI atomURI,
                                                                                                                                                                                                                                                                                                                                                                                                                        @Param(value="messageType")
                                                                                                                                                                                                                                                                                                                                                                                                                        WonMessageType messageType,
                                                                                                                                                                                                                                                                                                                                                                                                                        org.springframework.data.domain.Pageable pageable)

getConnectionsBeforeByActivityDate

@Query(value="select conn from Connection conn where conn.connectionURI in (select msg.parentURI from MessageEventPlaceholder msg where (((msg.senderAtomURI = :atom and msg.senderURI = msg.parentURI)    or (msg.recipientAtomURI = :atom and msg.recipientURI = msg.parentURI)) and (msg.creationDate < :referenceDate))group by msg.parentURI having max(msg.creationDate) < :resumeDate)")
org.springframework.data.domain.Slice<Connection> getConnectionsBeforeByActivityDate(@Param(value="atom")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     java.net.URI atomURI,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     @Param(value="resumeDate")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     java.util.Date resumeEventDate,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     @Param(value="referenceDate")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     java.util.Date referenceDate,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     org.springframework.data.domain.Pageable pageable)

getConnectionsBeforeByActivityDate

@Query(value="select conn from Connection conn where conn.connectionURI in (select msg.parentURI from MessageEventPlaceholder msg where (((msg.senderAtomURI = :atom and msg.senderURI = msg.parentURI) or (msg.recipientAtomURI = :atom and msg.recipientURI = msg.parentURI))    and (msg.creationDate < :referenceDate) and (msg.messageType = :messageType))group by msg.parentURI having max(msg.creationDate) < :resumeDate)")
org.springframework.data.domain.Slice<Connection> getConnectionsBeforeByActivityDate(@Param(value="atom")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          java.net.URI atomURI,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          @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)

getConnectionsAfterByActivityDate

@Query(value="select conn from Connection conn where conn.connectionURI in (select msg.parentURI from MessageEventPlaceholder msg where (((msg.senderAtomURI = :atom and msg.senderURI = msg.parentURI)    or (msg.recipientAtomURI = :atom and msg.recipientURI = msg.parentURI)) and (msg.creationDate < :referenceDate))group by msg.parentURI having max(msg.creationDate) > :resumeDate)")
org.springframework.data.domain.Slice<Connection> getConnectionsAfterByActivityDate(@Param(value="atom")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    java.net.URI atomURI,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @Param(value="resumeDate")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    java.util.Date resumeEventDate,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    @Param(value="referenceDate")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    java.util.Date referenceDate,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    org.springframework.data.domain.Pageable pageable)

getConnectionsAfterByActivityDate

@Query(value="select conn from Connection conn where conn.connectionURI in (select msg.parentURI from MessageEventPlaceholder msg where (((msg.senderAtomURI = :atom and msg.senderURI = msg.parentURI) or (msg.recipientAtomURI = :atom and msg.recipientURI = msg.parentURI))    and (msg.creationDate < :referenceDate) and (msg.messageType = :messageType))group by msg.parentURI having max(msg.creationDate) > :resumeDate)")
org.springframework.data.domain.Slice<Connection> getConnectionsAfterByActivityDate(@Param(value="atom")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         java.net.URI atomURI,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         @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)