Package org.vrspace.server.core

Interface VRObjectRepository

All Superinterfaces:

org.springframework.data.repository.CrudRepository<Entity,Long>, org.springframework.data.neo4j.repository.Neo4jRepository<Entity,Long>, org.springframework.data.repository.PagingAndSortingRepository<Entity,Long>, org.springframework.data.repository.query.QueryByExampleExecutor<Entity>, org.springframework.data.repository.Repository<Entity,Long>, VRSpaceDB

@DependsOn("database")
public interface VRObjectRepository
extends org.springframework.data.neo4j.repository.Neo4jRepository<Entity,Long>, VRSpaceDB

Field Summary

Fields

Modifier and Type	Field	Description
static final org.slf4j.Logger	log

Method Summary

Modifier and Type	Method	Description
default List<WorldStatus>	countUsers()
int	countUsers(long worldId)
int	countUsers(long worldId, boolean active)
default void	delete(VRObject o)
default void	deleteById(Long id)
default void	deleteMembers(Class<?> cls, VRObject obj)
default void	deleteWorld(World world)
default Optional<Entity>	findById(Long id)
Optional<ContentCategory>	findContentCategoryByName(String name)
Optional<GltfModel>	findGltfModelByUid(String uid)
Optional<UserGroup>	findGroup(long clientId, long groupId)
Optional<UserGroup>	findGroup(long clientId, String groupName)
Optional<UserGroup>	findGroup(String groupName)
Optional<GroupMember>	findGroupMember(long groupId, long clientId)
Optional<Ownership>	findOwnership(long ownerId, long ownedId)	WARNING this doesn't return full, useful owned Entity - e.g.
Optional<UserData>	findUserData(long objectId, String key)
Set<VRObject>	getAllInWorld(Long worldId)
default Client	getClient(Long id)
<T extends Embedded> T	getMember(Class<T> cls, Long id)
List<Ownership>	getOwnedObjects(long clientId)	WARNING this doesn't return full, useful owned VRObject - position and other members are missing - use listOwnedObjects instead
default List<Ownership>	getOwners(long objectId)
default Ownership	getOwnership(long ownerId, long ownedId)
List<Ownership>	getOwnersOf(long objectId)	WARNING this doesn't return full, useful owned Entity - position and other members are missing - use getOwners instead
Set<VRObject>	getPermanents(Long worldId)
Set<Point>	getPoints(double x1, double y1, double z1, double x2, double y2, double z2)
default Set<Point>	getPoints(Point from, Point to)
Set<VRObject>	getRange(Long worldId, double x1, double y1, double z1, double x2, double y2, double z2)
default Set<VRObject>	getRange(Long worldId, Point from, Point to)
TerrainPoint	getTerrainPoint(Long terrainId, Long index)
Set<TerrainPoint>	getTerrainPoints(Long terrainId)
World	getWorldByName(String name)
List<Client>	listGroupClients(long groupId)
List<GroupMember>	listGroupMembers(long groupId)
List<GroupMember>	listGroupMemberships(long clientId)
List<UserGroup>	listOwnedGroups(long clientId)
default List<Ownership>	listOwnedObjects(long ownerId)
List<GroupMember>	listPendingInvitations(long clientId)
List<GroupMember>	listPendingRequests(long groupId)
List<UserData>	listUserData(long objectId)
List<UserGroup>	listUserGroups(long clientId)
List<World>	listWorlds()
List<GroupMessage>	messagesSince(long groupId, Instant since)
default void	nullSafeDelete(Entity e)
Integer	unreadMessageCount(long groupId, Instant since)

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

count, delete, deleteAll, deleteAll, deleteAllById, existsById, save

Methods inherited from interface org.springframework.data.neo4j.repository.Neo4jRepository

findAll, findAll, findAll, findAll, findAllById, saveAll

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

findAll

Methods inherited from interface org.springframework.data.repository.query.QueryByExampleExecutor

count, exists, findAll, findBy, findOne

Methods inherited from interface org.vrspace.server.core.VRSpaceDB

deleteById, findById, get, get, getClientByName, getClientByName

Field Details

log

static final org.slf4j.Logger log

Method Details

findById

default Optional<Entity> findById(Long id)

Specified by:

findById in interface org.springframework.data.repository.CrudRepository<Entity,Long>

deleteById

default void deleteById(Long id)

Specified by:

deleteById in interface org.springframework.data.repository.CrudRepository<Entity,Long>

getPermanents

@Query("MATCH (o:VRObject{permanent:true}) WHERE o.worldId=$worldId RETURN o")
Set<VRObject> getPermanents(Long worldId)

getClient

default Client getClient(Long id)

getAllInWorld

@Query("MATCH (o:VRObject) WHERE o.worldId = $worldId RETURN o")
Set<VRObject> getAllInWorld(Long worldId)

deleteWorld

default void deleteWorld(World world)

getWorldByName

@Query("MATCH (o:World) WHERE o.name = $name RETURN o")
World getWorldByName(String name)

getRange

default Set<VRObject> getRange(Long worldId,
 Point from,
 Point to)

getRange

@Query("MATCH (o:VRObject)-[r:HAS_POSITION]->(p:Point) WHERE o.worldId = $worldId AND p.x >= $x1 AND p.y >= $y1 AND p.z >= $z1 AND p.x <= $x2 AND p.y <= $y2 AND p.z <= $z2 RETURN o,r,p")
Set<VRObject> getRange(Long worldId,
 double x1,
 double y1,
 double z1,
 double x2,
 double y2,
 double z2)

getPoints

default Set<Point> getPoints(Point from,
 Point to)

getPoints

@Query("MATCH (p:Point) WHERE p.x >= $x1 AND p.y >= $y1 AND p.z >= $z1 AND p.x <= $x2 AND p.y <= $y2 AND p.z <= $z2 RETURN p")
Set<Point> getPoints(double x1,
 double y1,
 double z1,
 double x2,
 double y2,
 double z2)

getMember

@Query("MATCH (o:Entity) WHERE ID(o) = $id RETURN o")
<T extends Embedded> T getMember(Class<T> cls,
 Long id)

delete

default void delete(VRObject o)

deleteMembers

default void deleteMembers(Class<?> cls,
 VRObject obj)
                    throws NoSuchMethodException,
SecurityException,
IllegalAccessException,
IllegalArgumentException,
InvocationTargetException

Throws:

NoSuchMethodException

SecurityException

IllegalAccessException

IllegalArgumentException

InvocationTargetException

nullSafeDelete

default void nullSafeDelete(Entity e)

findGltfModelByUid

Optional<GltfModel> findGltfModelByUid(String uid)

findContentCategoryByName

Optional<ContentCategory> findContentCategoryByName(String name)

listWorlds

@Query("MATCH (o:World) RETURN o")
List<World> listWorlds()

countUsers

@Query("MATCH (o:Client) WHERE o.worldId = $worldId RETURN count(*)")
int countUsers(long worldId)

countUsers

@Query("MATCH (o:Client) WHERE o.worldId = $worldId AND o.active = $active RETURN count(*)")
int countUsers(long worldId,
 boolean active)

countUsers

default List<WorldStatus> countUsers()

getOwnedObjects

@Query("MATCH (obj:VRObject)<-[owned:IS_OWNED]-(o:Ownership)-[owns:IS_OWNER]->(c:Client) WHERE ID(c) = $clientId RETURN o,owns,c,owned,obj")
List<Ownership> getOwnedObjects(long clientId)

WARNING this doesn't return full, useful owned VRObject - position and other members are missing - use listOwnedObjects instead

Parameters:

clientId -

Returns:

list of all ownerships

listOwnedObjects

default List<Ownership> listOwnedObjects(long ownerId)

getOwnersOf

@Query("MATCH (obj:Entity)<-[owned:IS_OWNED]-(o:Ownership)-[owns:IS_OWNER]->(c:Client) WHERE ID(obj) = $objectId RETURN o,owns,c,owned,obj")
List<Ownership> getOwnersOf(long objectId)

WARNING this doesn't return full, useful owned Entity - position and other members are missing - use getOwners instead

Returns:

list of all owners

getOwners

default List<Ownership> getOwners(long objectId)

findOwnership

@Query("MATCH (obj:Entity)<-[owned:IS_OWNED]-(o:Ownership)-[owns:IS_OWNER]->(c:Client) WHERE ID(c) = $ownerId AND ID(obj) = $ownedId RETURN o,owns,c,owned,obj")
Optional<Ownership> findOwnership(long ownerId,
 long ownedId)

WARNING this doesn't return full, useful owned Entity - e.g. VRObject position and other members are missing - use getOwnership instead

getOwnership

default Ownership getOwnership(long ownerId,
 long ownedId)

getTerrainPoints

@Query("MATCH (tp:TerrainPoint)-[r:IS_POINT_OF]->(t:Terrain) WHERE ID(t)=$terrainId RETURN tp")
Set<TerrainPoint> getTerrainPoints(Long terrainId)

getTerrainPoint

@Query("MATCH (tp:TerrainPoint)-[r:IS_POINT_OF]->(t:Terrain) WHERE ID(t)=$terrainId and tp.index=$index RETURN tp")
TerrainPoint getTerrainPoint(Long terrainId,
 Long index)

listOwnedGroups

@Query("MATCH (ug:UserGroup)<-[owned:IS_OWNED]-(o:Ownership)-[owns:IS_OWNER]->(c:Client) WHERE ID(c) = $clientId RETURN o,owns,c,owned,ug ORDER BY ug.name")
List<UserGroup> listOwnedGroups(long clientId)

listUserGroups

@Query("MATCH (c:Client)<-[mc:MEMBER_CLIENT]-(gm:GroupMember)-[r:IS_MEMBER_OF]->(ug:UserGroup) WHERE ID(c)=$clientId AND gm.pendingInvite IS NULL AND gm.pendingRequest IS NULL RETURN ug ORDER BY ug.name")
List<UserGroup> listUserGroups(long clientId)

listGroupMemberships

@Query("MATCH (c:Client)<-[mc:MEMBER_CLIENT]-(gm:GroupMember)-[r:IS_MEMBER_OF]->(ug:UserGroup) WHERE ID(c)=$clientId AND gm.pendingInvite IS NULL AND gm.pendingRequest IS NULL RETURN gm, r, ug ORDER BY ug.name")
List<GroupMember> listGroupMemberships(long clientId)

listGroupClients

@Query("MATCH (c:Client)<-[mc:MEMBER_CLIENT]-(gm:GroupMember)-[r:IS_MEMBER_OF]->(ug:UserGroup) WHERE ID(ug)=$groupId AND gm.pendingRequest IS NULL AND gm.pendingInvite IS NULL RETURN c")
List<Client> listGroupClients(long groupId)

listGroupMembers

@Query("MATCH (gm:GroupMember)-[r:IS_MEMBER_OF]->(ug:UserGroup) WHERE ID(ug)=$groupId AND gm.pendingRequest IS NULL AND gm.pendingInvite IS NULL RETURN gm, r, ug")
List<GroupMember> listGroupMembers(long groupId)

findGroupMember

@Query("MATCH (c:Client)<-[mc:MEMBER_CLIENT]-(gm:GroupMember)-[r:IS_MEMBER_OF]->(ug:UserGroup) WHERE ID(ug)=$groupId AND ID(c)=$clientId RETURN gm, c, mc, r, ug")
Optional<GroupMember> findGroupMember(long groupId,
 long clientId)

findGroup

@Query("MATCH (c:Client)<-[mc:MEMBER_CLIENT]-(gm:GroupMember)-[r:IS_MEMBER_OF]->(ug:UserGroup) WHERE ID(c)=$clientId AND ug.name=$groupName RETURN ug")
Optional<UserGroup> findGroup(long clientId,
 String groupName)

findGroup

@Query("MATCH (c:Client)<-[mc:MEMBER_CLIENT]-(gm:GroupMember)-[r:IS_MEMBER_OF]->(ug:UserGroup) WHERE ID(c)=$clientId AND ID(ug)=$groupId RETURN ug")
Optional<UserGroup> findGroup(long clientId,
 long groupId)

findGroup

@Query("MATCH (c:Client)<-[mc:MEMBER_CLIENT]-(gm:GroupMember)-[r:IS_MEMBER_OF]->(ug:UserGroup) WHERE AND ug.name=$groupName RETURN ug")
Optional<UserGroup> findGroup(String groupName)

listUserData

@Query("MATCH (ud:UserData)-[r:USER_DATA]->(o:VRObject) WHERE ID(o)=$objectId RETURN ud, r, o")
List<UserData> listUserData(long objectId)

findUserData

@Query("MATCH (ud:UserData)-[r:USER_DATA]->(o:VRObject) WHERE ID(o)=$objectId AND ud.key=$key RETURN ud, r, o")
Optional<UserData> findUserData(long objectId,
 String key)

listPendingRequests

@Query("MATCH (c:Client)<-[mc:MEMBER_CLIENT]-(gm:GroupMember)-[r:IS_MEMBER_OF]->(ug:UserGroup) WHERE ID(ug)=$groupId AND gm.pendingRequest IS NOT NULL RETURN gm, c, mc, r, ug")
List<GroupMember> listPendingRequests(long groupId)

listPendingInvitations

@Query("MATCH (c:Client)<-[mc:MEMBER_CLIENT]-(gm:GroupMember)-[r:IS_MEMBER_OF]->(ug:UserGroup), (s:Client)<-[sc:SPONSOR_CLIENT]-(gm:GroupMember) WHERE ID(c)=$clientId AND gm.pendingInvite IS NOT NULL RETURN gm, c, mc, r, ug, sc, s ORDER BY ug.name")
List<GroupMember> listPendingInvitations(long clientId)

unreadMessageCount

@Query("MATCH (msg:GroupMessage)-[r:PARENT_GROUP]->(ug:UserGroup) WHERE ID(ug)=$groupId AND ($since IS NULL OR msg.timestamp >= $since) return count(msg)")
Integer unreadMessageCount(long groupId,
 Instant since)

messagesSince

@Query("MATCH (c:Client)<-[mc:SENDER_CLIENT]-(msg:GroupMessage)-[r:PARENT_GROUP]->(ug:UserGroup) WHERE ID(ug)=$groupId AND ($since IS NULL OR msg.timestamp >= $since) return msg, mc, c ORDER BY msg.timestamp")
List<GroupMessage> messagesSince(long groupId,
 Instant since)