Examples with PerServerContainer com.djrapitops.plan.delivery.domain.container.PerServerContainer used on opensource projects

Example 1 with PerServerContainer

use of com.djrapitops.plan.delivery.domain.container.PerServerContainer in project Plan by plan-player-analytics.

the class PerServerContainerQuery method executeQuery.

@Override
public PerServerContainer executeQuery(SQLDB db) {
    PerServerContainer perServerContainer = new PerServerContainer();
    userInformation(db, perServerContainer);
    lastSeen(db, perServerContainer);
    playerKillCount(db, perServerContainer);
    mobKillCount(db, perServerContainer);
    totalDeathCount(db, perServerContainer);
    worldTimes(db, perServerContainer);
    Map<ServerUUID, List<FinishedSession>> sessions = db.query(SessionQueries.fetchSessionsOfPlayer(playerUUID));
    for (Map.Entry<ServerUUID, List<FinishedSession>> entry : sessions.entrySet()) {
        ServerUUID serverUUID = entry.getKey();
        List<FinishedSession> serverSessions = entry.getValue();
        DataContainer serverContainer = perServerContainer.getOrDefault(serverUUID, new SupplierDataContainer());
        serverContainer.putRawData(PerServerKeys.SESSIONS, serverSessions);
        perServerContainer.put(serverUUID, serverContainer);
    }
    return perServerContainer;
}

Example 2 with PerServerContainer

use of com.djrapitops.plan.delivery.domain.container.PerServerContainer in project Plan by plan-player-analytics.

the class ServerPlayerContainersQuery method executeQuery.

@Override
public List<PlayerContainer> executeQuery(SQLDB db) {
    List<PlayerContainer> containers = new ArrayList<>();
    Collection<BaseUser> baseUsers = db.query(BaseUserQueries.fetchServerBaseUsers(serverUUID));
    Map<UUID, List<GeoInfo>> geoInformation = db.query(GeoInfoQueries.fetchServerGeoInformation(serverUUID));
    Map<UUID, List<Nickname>> nicknames = db.query(NicknameQueries.fetchNicknameDataOfServer(serverUUID));
    Map<UUID, List<Ping>> pingData = db.query(PingQueries.fetchPingDataOfServer(serverUUID));
    Map<UUID, List<FinishedSession>> sessions = db.query(SessionQueries.fetchSessionsOfServer(serverUUID));
    Map<UUID, UserInfo> userInformation = db.query(UserInfoQueries.fetchUserInformationOfServer(serverUUID));
    Map<UUID, PerServerContainer> perServerInfo = getPerServerData(userInformation, sessions, pingData);
    for (BaseUser user : baseUsers) {
        PlayerContainer container = new PlayerContainer();
        // BaseUser
        UUID uuid = user.getUuid();
        container.putRawData(PlayerKeys.UUID, uuid);
        container.putRawData(PlayerKeys.NAME, user.getName());
        container.putRawData(PlayerKeys.REGISTERED, user.getRegistered());
        container.putRawData(PlayerKeys.KICK_COUNT, user.getTimesKicked());
        // GeoInfo
        container.putRawData(PlayerKeys.GEO_INFO, geoInformation.getOrDefault(uuid, Collections.emptyList()));
        // Ping
        container.putRawData(PlayerKeys.PING, pingData.get(uuid));
        // Nickname, only used for the raw server JSON.
        container.putRawData(PlayerKeys.NICKNAMES, nicknames.get(uuid));
        // PerServerContainer
        container.putRawData(PlayerKeys.PER_SERVER, perServerInfo.get(uuid));
        container.putCachingSupplier(PlayerKeys.SESSIONS, () -> {
            List<FinishedSession> playerSessions = sessions.getOrDefault(uuid, new ArrayList<>());
            container.getValue(PlayerKeys.ACTIVE_SESSION).map(ActiveSession::toFinishedSessionFromStillActive).ifPresent(playerSessions::add);
            return playerSessions;
        });
        // Calculating getters
        container.putCachingSupplier(PlayerKeys.WORLD_TIMES, () -> {
            WorldTimes worldTimes = new PerServerMutator(container.getUnsafe(PlayerKeys.PER_SERVER)).flatMapWorldTimes();
            container.getValue(PlayerKeys.ACTIVE_SESSION).ifPresent(session -> worldTimes.add(session.getExtraData(WorldTimes.class).orElseGet(WorldTimes::new)));
            return worldTimes;
        });
        container.putSupplier(PlayerKeys.BANNED, () -> PerServerMutator.forContainer(container).isBanned());
        container.putSupplier(PlayerKeys.OPERATOR, () -> PerServerMutator.forContainer(container).isOperator());
        container.putSupplier(PlayerKeys.LAST_SEEN, () -> SessionsMutator.forContainer(container).toLastSeen());
        container.putSupplier(PlayerKeys.PLAYER_KILLS, () -> SessionsMutator.forContainer(container).toPlayerKillList());
        container.putSupplier(PlayerKeys.PLAYER_KILL_COUNT, () -> container.getUnsafe(PlayerKeys.PLAYER_KILLS).size());
        container.putSupplier(PlayerKeys.MOB_KILL_COUNT, () -> SessionsMutator.forContainer(container).toMobKillCount());
        container.putSupplier(PlayerKeys.DEATH_COUNT, () -> SessionsMutator.forContainer(container).toDeathCount());
        containers.add(container);
    }
    return containers;
}

Example 3 with PerServerContainer

use of com.djrapitops.plan.delivery.domain.container.PerServerContainer in project Plan by plan-player-analytics.

the class ServerPlayerContainersQuery method getPerServerData.

/**
 * Create PerServerContainers for each player.
 *
 * @param userInformation Map: Player UUID - UserInfo of this server
 * @param sessions        Map: Player UUID - List of Sessions of this server
 * @param ping            Map: Player UUID - List of Ping data of this server
 * @return Map: Player UUID - PerServerContainer
 */
private Map<UUID, PerServerContainer> getPerServerData(Map<UUID, UserInfo> userInformation, Map<UUID, List<FinishedSession>> sessions, Map<UUID, List<Ping>> ping) {
    Map<UUID, PerServerContainer> perServerContainers = new HashMap<>();
    for (Map.Entry<UUID, UserInfo> entry : userInformation.entrySet()) {
        UUID playerUUID = entry.getKey();
        PerServerContainer perServerContainer = perServerContainers.getOrDefault(playerUUID, new PerServerContainer());
        // Information found withing UserInfo
        perServerContainer.putUserInfo(entry.getValue());
        // Session list
        perServerContainer.putSessions(sessions.get(playerUUID));
        // Ping list
        perServerContainer.putPing(ping.get(playerUUID));
        // Derivative values
        perServerContainer.putCalculatingSuppliers();
        perServerContainers.put(playerUUID, perServerContainer);
    }
    return perServerContainers;
}

Example 4 with PerServerContainer

use of com.djrapitops.plan.delivery.domain.container.PerServerContainer in project Plan by plan-player-analytics.

the class PlayerContainerQuery method executeQuery.

@Override
public PlayerContainer executeQuery(SQLDB db) {
    PlayerContainer container = new PlayerContainer();
    container.putRawData(PlayerKeys.UUID, uuid);
    Key<BaseUser> baseUserKey = new Key<>(BaseUser.class, "BASE_USER");
    container.putSupplier(baseUserKey, () -> db.query(BaseUserQueries.fetchBaseUserOfPlayer(uuid)).orElse(null));
    container.putSupplier(PlayerKeys.REGISTERED, () -> container.getValue(baseUserKey).map(BaseUser::getRegistered).orElse(null));
    container.putSupplier(PlayerKeys.NAME, () -> container.getValue(baseUserKey).map(BaseUser::getName).orElse(null));
    container.putSupplier(PlayerKeys.KICK_COUNT, () -> container.getValue(baseUserKey).map(BaseUser::getTimesKicked).orElse(null));
    container.putCachingSupplier(PlayerKeys.GEO_INFO, () -> db.query(GeoInfoQueries.fetchPlayerGeoInformation(uuid)));
    container.putCachingSupplier(PlayerKeys.PING, () -> db.query(PingQueries.fetchPingDataOfPlayer(uuid)));
    container.putCachingSupplier(PlayerKeys.NICKNAMES, () -> db.query(NicknameQueries.fetchNicknameDataOfPlayer(uuid)));
    container.putCachingSupplier(PlayerKeys.PER_SERVER, () -> db.query(new PerServerContainerQuery(uuid)));
    container.putSupplier(PlayerKeys.BANNED, () -> new PerServerMutator(container.getValue(PlayerKeys.PER_SERVER).orElse(new PerServerContainer())).isBanned());
    container.putSupplier(PlayerKeys.OPERATOR, () -> new PerServerMutator(container.getValue(PlayerKeys.PER_SERVER).orElse(new PerServerContainer())).isOperator());
    container.putCachingSupplier(PlayerKeys.SESSIONS, () -> {
        List<FinishedSession> sessions = new PerServerMutator(container.getValue(PlayerKeys.PER_SERVER).orElse(new PerServerContainer())).flatMapSessions();
        container.getValue(PlayerKeys.ACTIVE_SESSION).map(ActiveSession::toFinishedSessionFromStillActive).ifPresent(sessions::add);
        return sessions;
    });
    container.putCachingSupplier(PlayerKeys.WORLD_TIMES, () -> {
        WorldTimes worldTimes = db.query(WorldTimesQueries.fetchPlayerTotalWorldTimes(uuid));
        container.getValue(PlayerKeys.ACTIVE_SESSION).ifPresent(session -> worldTimes.add(session.getExtraData(WorldTimes.class).orElseGet(WorldTimes::new)));
        return worldTimes;
    });
    container.putSupplier(PlayerKeys.LAST_SEEN, () -> SessionsMutator.forContainer(container).toLastSeen());
    container.putSupplier(PlayerKeys.PLAYER_KILLS, () -> db.query(KillQueries.fetchPlayerKillsOfPlayer(uuid)));
    container.putSupplier(PlayerKeys.PLAYER_DEATHS_KILLS, () -> db.query(KillQueries.fetchPlayerDeathsOfPlayer(uuid)));
    container.putSupplier(PlayerKeys.PLAYER_KILL_COUNT, () -> container.getValue(PlayerKeys.PLAYER_KILLS).map(Collection::size).orElse(0));
    container.putSupplier(PlayerKeys.MOB_KILL_COUNT, () -> SessionsMutator.forContainer(container).toMobKillCount());
    container.putSupplier(PlayerKeys.DEATH_COUNT, () -> SessionsMutator.forContainer(container).toDeathCount());
    SessionCache.getCachedSession(uuid).ifPresent(session -> container.putRawData(PlayerKeys.ACTIVE_SESSION, session));
    return container;
}