Fix test data and permission checks on datapoint requests

AuroraLS3 · AuroraLS3 · commit cec93b427af3 · 2026-04-30T18:47:12.000+03:00
diff --git a/Plan/common/src/main/java/com/djrapitops/plan/delivery/rendering/json/datapoint/types/PlayersOnlineCurrent.java b/Plan/common/src/main/java/com/djrapitops/plan/delivery/rendering/json/datapoint/types/PlayersOnlineCurrent.java
@@ -68,6 +68,9 @@ public Optional<Integer> getValue(GenericFilter filter) {
                 serverUUIDs = dbSystem.getDatabase().query(ServerQueries.fetchProxyServerUUIDs());
             }
         }
+        if (serverUUIDs.isEmpty()) {
+            return Optional.of(serverSensor.getOnlinePlayerCount());
+        }
 
         if (serverUUIDs.size() == 1) {
             ServerUUID serverUUID = serverUUIDs.get(0);
diff --git a/Plan/common/src/test/java/com/djrapitops/plan/delivery/export/ExportTestUtilities.java b/Plan/common/src/test/java/com/djrapitops/plan/delivery/export/ExportTestUtilities.java
@@ -133,7 +133,7 @@ static void savePlayerData(Database database, ServerUUID serverUUID) {
     }
 
     static void saveServerData(Database database, ServerUUID serverUUID) {
-        RandomData.randomDateOrderedTPS(5).forEach(tps -> database.executeTransaction(new TPSStoreTransaction(serverUUID, tps)).join());
+        RandomData.randomDateOrderedTPS(1).forEach(tps -> database.executeTransaction(new TPSStoreTransaction(serverUUID, tps)).join());
     }
 
     public static List<String> getEndpointsToTest(ServerUUID serverUUID) {
diff --git a/Plan/common/src/test/java/com/djrapitops/plan/delivery/webserver/AccessControlTest.java b/Plan/common/src/test/java/com/djrapitops/plan/delivery/webserver/AccessControlTest.java
@@ -61,6 +61,7 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
 import java.util.stream.Stream;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -306,9 +307,10 @@ static void setUpClass(@TempDir Path tempDir) throws Exception {
                 TestConstants.SERVER_NAME,
                 address,
                 TestConstants.VERSION)));
-        for (TPS tps : RandomData.randomTPS()) {
-            database.executeInTransaction(DataStoreQueries.storeTPS(TestConstants.SERVER_UUID, tps));
+        for (TPS tps : RandomData.randomDateOrderedTPS(1)) {
+            database.executeInTransaction(DataStoreQueries.storeTPS(TestConstants.SERVER_UUID, tps)).join();
         }
+        database.executeInTransaction(DataStoreQueries.storeTPS(TestConstants.SERVER_UUID, RandomData.randomTPSAtDate(System.currentTimeMillis() - TimeUnit.SECONDS.toMillis(5))));
 
         Caller caller = system.getApiServices().getExtensionService().register(new ExtensionsDatabaseTest.PlayerExtension())
                 .orElseThrow(AssertionError::new);
diff --git a/Plan/common/src/test/java/com/djrapitops/plan/delivery/webserver/AccessControlVisibilityTest.java b/Plan/common/src/test/java/com/djrapitops/plan/delivery/webserver/AccessControlVisibilityTest.java
@@ -27,6 +27,7 @@
 import com.djrapitops.plan.settings.config.paths.DisplaySettings;
 import com.djrapitops.plan.settings.config.paths.WebserverSettings;
 import com.djrapitops.plan.storage.database.Database;
+import com.djrapitops.plan.storage.database.queries.DataStoreQueries;
 import com.djrapitops.plan.storage.database.queries.objects.ServerQueries;
 import com.djrapitops.plan.storage.database.transactions.StoreServerInformationTransaction;
 import com.djrapitops.plan.storage.database.transactions.commands.RemoveWebGroupsTransaction;
@@ -198,6 +199,13 @@ private static void storePlayer(Database database, ServerUUID serverUUID, UUID p
                 .get();
     }
 
+    @BeforeEach
+    void setUp(Database database, ServerUUID serverUUID) {
+        database.executeInTransaction(
+                DataStoreQueries.storeTPS(serverUUID,
+                        RandomData.randomTPSAtDate(System.currentTimeMillis() - TimeUnit.SECONDS.toMillis(5)))).join();
+    }
+
     @AfterEach
     void tearDownTest(WebDriver driver) {
         String address = "https://localhost:" + TEST_PORT_NUMBER + "/auth/logout";
@@ -295,10 +303,11 @@ void serverPageElementNotVisible(WebPermission permission, String element, Strin
         assertNoLogs(driver, address);
     }
 
-    private void registerProxy(Database database) throws ExecutionException, InterruptedException {
+    private void registerProxy(Database database) {
         database.executeTransaction(new StoreServerInformationTransaction(
                 new Server(null, TestConstants.SERVER_TWO_UUID, "Proxy", "https://localhost", true, TestConstants.VERSION)
-        )).get();
+        )).join();
+        database.executeInTransaction(DataStoreQueries.storeTPS(TestConstants.SERVER_TWO_UUID, RandomData.randomTPSAtDate(System.currentTimeMillis() - 1)));
         Awaitility.await("Proxy was not registered")
                 .atMost(5, TimeUnit.SECONDS)
                 .until(() -> !database.query(ServerQueries.fetchProxyServers()).isEmpty());
diff --git a/Plan/common/src/testFixtures/java/utilities/RandomData.java b/Plan/common/src/testFixtures/java/utilities/RandomData.java
@@ -85,7 +85,10 @@ public static List<TPS> randomTPS() {
             int randEntities = r.nextInt(10000);
             int randChunks = r.nextInt(10000);
             long randDisk = r.nextLong() % 100000L;
-            test.add(new TPS(randDate, randTPS, randPlayers, randCPU, randMemory, randEntities, randChunks, randDisk));
+            TPS tps = new TPS(randDate, randTPS, randPlayers, randCPU, randMemory, randEntities, randChunks, randDisk);
+            tps.setMsptAverage(randTPS / 20.0);
+            tps.setMspt95thPercentile(randTPS / 20.0);
+            test.add(tps);
         }
         return test;
     }
@@ -100,16 +103,30 @@ public static List<TPS> randomDateOrderedTPS(long minimumDay) {
         int previousPlayers = randomInt(0, 100);
         for (int i = 0; i < randomInt(50, 100); i++) {
             int randInt = r.nextInt();
-            double randTps = r.nextDouble() * 20;
+            double randTps = Math.abs(r.nextDouble() * 20);
             long randLong = Math.abs(r.nextLong());
-            test.add(new TPS(previousTimestamp, randTps, previousPlayers, randLong, randLong, randInt, randInt, randLong));
+            TPS tps = new TPS(previousTimestamp, randTps, previousPlayers, randLong, randLong, randInt, randInt, randLong);
+            tps.setMsptAverage(randTps / 20.0);
+            tps.setMspt95thPercentile(randTps / 20.0);
+            test.add(tps);
             boolean reboot = Math.random() < 0.10;
             previousTimestamp = previousTimestamp + (reboot ? TimeUnit.MINUTES.toMillis(1) : TimeUnit.MINUTES.toMillis(10));
             previousPlayers = Math.max(previousPlayers + r.nextInt(10) - 10, 0);
         }
         return test;
     }
 
+    public static TPS randomTPSAtDate(long epoch) {
+        int randInt = r.nextInt();
+        double randTps = Math.abs(r.nextDouble() * 20);
+        long randLong = Math.abs(r.nextLong());
+        int previousPlayers = randomInt(0, 100);
+        TPS tps = new TPS(epoch, randTps, previousPlayers, randLong, randLong, randInt, randInt, randLong);
+        tps.setMsptAverage(randTps / 20.0);
+        tps.setMspt95thPercentile(randTps / 20.0);
+        return tps;
+    }
+
     public static List<FinishedSession> randomSessions() {
         return pickMultiple(randomInt(15, 30),
                 () -> randomSession(
@@ -251,6 +268,6 @@ public static List<JoinAddress> generateJoinAddresses(int n) {
     }
 
     public static List<UUID> randomUUIDs(int n) {
-        return IntStream.range(0, n).mapToObj(i -> UUID.randomUUID()).toList();
+        return IntStream.range(0, n).mapToObj(_ -> UUID.randomUUID()).toList();
     }
 }
diff --git a/Plan/react/dashboard/src/components/cards/network/QuickViewGraphCard.jsx b/Plan/react/dashboard/src/components/cards/network/QuickViewGraphCard.jsx
@@ -8,12 +8,15 @@ import {useDataRequest} from "../../../hooks/dataFetchHook.js";
 import {fetchPlayersOnlineGraph} from "../../../service/serverService.js";
 import {ErrorViewCard} from "../../../views/ErrorView.tsx";
 import {CardLoader} from "../../navigation/Loader.tsx";
+import {useAuth} from "../../../hooks/authenticationHook.tsx";
 
 const QuickViewGraphCard = ({server}) => {
     const {t} = useTranslation();
+    const {hasPermission} = useAuth();
     const {data, loadingError} = useDataRequest(
         fetchPlayersOnlineGraph,
-        [server.serverUUID])
+        [server.serverUUID],
+        hasPermission('page.server.overview.players.online.graph'))
 
     if (loadingError) return <ErrorViewCard error={loadingError}/>
     if (!data) return <CardLoader/>;
diff --git a/Plan/react/dashboard/src/components/cards/network/ServersTableCard.jsx b/Plan/react/dashboard/src/components/cards/network/ServersTableCard.jsx
@@ -12,7 +12,7 @@ const SortDropDown = ({sortBy, sortReversed, setSortBy}) => {
     const {hasPermission} = useAuth();
 
     const sortOptions = Object.values(ServerSortOption)
-        .filter(sortBy => hasPermission(calculatePermission(sortBy.data)));
+        .filter(sortBy => hasPermission(calculatePermission(sortBy.data, {server: "true"})));
 
     const getSortIcon = useCallback(() => {
         return sortReversed ? sortBy.iconDesc : sortBy.iconAsc;
diff --git a/Plan/react/dashboard/src/components/cards/server/insights/SessionInsightsCard.jsx b/Plan/react/dashboard/src/components/cards/server/insights/SessionInsightsCard.jsx
@@ -45,8 +45,7 @@ const SessionInsightsCard = ({identifier}) => {
                             dataType={DatapointType.AFK_TIME}
                             filter={filter}
                             valueLabel={<>(<QueryDatapointValue dataType={DatapointType.AFK_TIME_PERCENTAGE}
-                                                                filter={filter}
-                                                                permission={"afk.time"}/>)</>}
+                                                                filter={filter}/>)</>}
             />
         </InsightsFor30DaysCard>
     )
diff --git a/Plan/react/dashboard/src/components/cards/server/values/ServerAsNumbersCard.jsx b/Plan/react/dashboard/src/components/cards/server/values/ServerAsNumbersCard.jsx
@@ -46,7 +46,7 @@ const ServerAsNumbersCard = () => {
                                         filter={filter} bold/>
                         <QueryDatapoint name={t('html.label.playersOnline')}
                                         color={'players-online'} icon={faUser}
-                                        dataType={DatapointType.PLAYERS_ONLINE}
+                                        dataType={DatapointType.PLAYERS_ONLINE} permission="players.online.current"
                                         filter={filter} bold/>
                         <hr/>
                         <QueryDatapoint
diff --git a/Plan/react/dashboard/src/components/datapoint/QueryDatapoint.tsx b/Plan/react/dashboard/src/components/datapoint/QueryDatapoint.tsx
@@ -2,6 +2,7 @@ import {
     Datapoint,
     DatapointType,
     DatapointTypeMap,
+    differingPermissions,
     FormatType,
     getDatapointUrl,
     NumericDatapointType
@@ -10,7 +11,7 @@ import {GenericFilter} from "../../dataHooks/model/GenericFilter";
 import {useNavigation} from "../../hooks/navigationHook";
 import {useQueries, useQuery} from "@tanstack/react-query";
 import {queryRetry} from "../../dataHooks/queryRetry";
-import React, {useEffect} from "react";
+import React, {useEffect, useRef} from "react";
 import {Datapoint as DatapointComponent, DatapointProps} from "./Datapoint";
 import FormattedTime from "../text/FormattedTime";
 import {DatapointLoader} from "../navigation/Loader";
@@ -28,7 +29,6 @@ import {faQuestionCircle} from "@fortawesome/free-regular-svg-icons";
 type Props<K extends DatapointType> = {
     dataType: K;
     filter?: GenericFilter;
-    permission?: string;
     fallbackUnavailableExplanation?: string
 } & Omit<DatapointProps, 'value'>;
 
@@ -91,9 +91,9 @@ function Format<K extends DatapointType>({value, formatType}: FormatProps<K>) {
     }
 }
 
-export function calculatePermission(dataType: DatapointType, permission?: string, filter?: GenericFilter) {
+export function calculatePermission(dataType: DatapointType, filter?: GenericFilter) {
     if (!dataType) return '';
-    const asPermission = permission || dataType.toLowerCase().replaceAll('_', '.');
+    const asPermission = differingPermissions[dataType] || dataType.toLowerCase().replaceAll('_', '.');
     if (filter) {
         if (filter.player) return 'data.player.' + asPermission;
         if (filter.server?.length) return 'data.server.' + asPermission;
@@ -102,14 +102,13 @@ export function calculatePermission(dataType: DatapointType, permission?: string
 }
 
 export function QueryDatapoint<K extends DatapointType>({
-                                                            permission,
                                                             dataType,
                                                             filter,
                                                             fallbackUnavailableExplanation,
                                                             ...props
                                                         }: Props<K>) {
     const {hasPermission} = useAuth();
-    const allowed = hasPermission(calculatePermission(dataType, permission, filter));
+    const allowed = hasPermission(calculatePermission(dataType, filter));
     const {data, isFetching, error} = useDatapointQuery(allowed, dataType, filter);
 
     if (!allowed) return null;
@@ -140,9 +139,9 @@ export function QueryDatapoint<K extends DatapointType>({
     />
 }
 
-export function QueryDatapointValue<K extends DatapointType>({permission, dataType, filter}: ValueProps<K>) {
+export function QueryDatapointValue<K extends DatapointType>({dataType, filter}: ValueProps<K>) {
     const {hasPermission} = useAuth();
-    const allowed = hasPermission(calculatePermission(dataType, permission, filter));
+    const allowed = hasPermission(calculatePermission(dataType, filter));
     const {data, isFetching, error} = useDatapointQuery(allowed, dataType, filter);
     const {t} = useTranslation();
 
@@ -161,14 +160,13 @@ export function QueryDatapointValue<K extends DatapointType>({permission, dataTy
 type TrendProps<K extends NumericDatapointType> = { downGood?: boolean, filter2: GenericFilter } & ValueProps<K>
 
 export function QueryDatapointTrend<K extends NumericDatapointType>({
-                                                                        permission,
                                                                         dataType,
                                                                         downGood,
                                                                         filter,
                                                                         filter2
                                                                     }: TrendProps<K>) {
     const {hasPermission} = useAuth();
-    const allowed = hasPermission(calculatePermission(dataType, permission, filter));
+    const allowed = hasPermission(calculatePermission(dataType, filter));
     const {data: before, error: error1} = useDatapointQuery(allowed, dataType, filter);
     const {data: after, error: error2} = useDatapointQuery(allowed, dataType, filter2);
 
@@ -194,20 +192,25 @@ export function QueryDatapointTrend<K extends NumericDatapointType>({
 
 export function useDatapointQuery<K extends DatapointType>(allowed: boolean, dataType: K, filter?: GenericFilter) {
     const {updateRequested} = useNavigation() as { updateRequested: number };
+    const prevUpdateRef = useRef<number | undefined>(undefined);
     const query = useQuery({
         queryKey: filter ? ['datapoint', dataType, ...Object.values(filter)] : ['datapoint', dataType],
         queryFn: () => getDatapoint(dataType, filter),
         retry: queryRetry,
         enabled: Boolean(allowed)
     });
     useEffect(() => {
-        query.refetch()
-    }, [updateRequested]);
+        if (allowed && prevUpdateRef.current && prevUpdateRef.current <= updateRequested) {
+            query.refetch()
+        }
+        prevUpdateRef.current = updateRequested;
+    }, [updateRequested, allowed]);
     return query;
 }
 
 export function useDatapointQueries<K extends DatapointType>(allowed: boolean, dataType: K, filters: GenericFilter[]) {
     const {updateRequested} = useNavigation() as { updateRequested: number };
+    const prevUpdateRef = useRef<number | undefined>(undefined);
     const query = useQueries({
         queries: filters.map(filter => ({
             queryKey: filter ? ['datapoint', dataType, ...Object.values(filter)] : ['datapoint', dataType],
@@ -217,8 +220,11 @@ export function useDatapointQueries<K extends DatapointType>(allowed: boolean, d
         }))
     });
     useEffect(() => {
-        query.forEach(q => q.refetch())
-    }, [updateRequested]);
+        if (allowed && prevUpdateRef.current && prevUpdateRef.current <= updateRequested) {
+            query.forEach(q => q.refetch())
+        }
+        prevUpdateRef.current = updateRequested;
+    }, [updateRequested, allowed]);
     return query;
 }
 
diff --git a/Plan/react/dashboard/src/components/table/QueryDatapointTable.tsx b/Plan/react/dashboard/src/components/table/QueryDatapointTable.tsx
@@ -62,12 +62,11 @@ export const QueryDatapointTable = ({comparisonHeader, filter, columns, rows, sh
         </tr>
         </thead>
         <tbody>
-        {rows.filter(row => hasPermission(calculatePermission(row.dataType, row.permission, filter)))
+        {rows.filter(row => hasPermission(calculatePermission(row.dataType, filter)))
             .map(row => <tr key={row.text} title={row.title}>
                 <td><Fa icon={row.icon} className={'col-' + row.color}/> {row.text}</td>
                 {columns.map(column => <td key={column.key + row.text}>
                     <QueryDatapointValue dataType={row.dataType}
-                                         permission={row.permission}
                                          filter={{...filter, ...column.filter}}/>
                 </td>)}
                 {showTrend && <td>
diff --git a/Plan/react/dashboard/src/components/table/ServersTable.jsx b/Plan/react/dashboard/src/components/table/ServersTable.jsx
@@ -31,16 +31,18 @@ import {useAuth} from "../../hooks/authenticationHook.tsx";
 
 const ServerRow = ({server, sortedBy, onQuickView}) => {
     const {t} = useTranslation();
+    const {hasPermission} = useAuth();
 
-    const {error: error30d} = useDatapointQuery(true, DatapointType.TPS_AVERAGE, {
+    const permission = hasPermission(calculatePermission(DatapointType.TPS_AVERAGE, {server: server.serverUUID}))
+    const {error: error30d} = useDatapointQuery(permission, DatapointType.TPS_AVERAGE, {
         server: server.serverUUID,
         afterMillisAgo: MS_MONTH
     })
-    const {error: error7d} = useDatapointQuery(true, DatapointType.TPS_AVERAGE, {
+    const {error: error7d} = useDatapointQuery(permission, DatapointType.TPS_AVERAGE, {
         server: server.serverUUID,
         afterMillisAgo: MS_WEEK
     })
-    const {error: error24h} = useDatapointQuery(true, DatapointType.TPS_AVERAGE, {
+    const {error: error24h} = useDatapointQuery(permission, DatapointType.TPS_AVERAGE, {
         server: server.serverUUID,
         afterMillisAgo: MS_24H
     })
@@ -72,7 +74,7 @@ const ServerRow = ({server, sortedBy, onQuickView}) => {
                                      }}/>
             </td>
             <td>
-                <QueryDatapointValue dataType={DatapointType.PLAYERS_ONLINE}
+                <QueryDatapointValue dataType={DatapointType.PLAYERS_ONLINE} permission="players.online.current"
                                      filter={{server: server.serverUUID}}/>
             </td>
             <td className="p-1">
@@ -184,8 +186,8 @@ const ServersTable = ({servers, onSelect, sortBy, sortReversed}) => {
     const {hasPermission} = useAuth();
 
     const sortedBy = ServerSortOption[sortBy.key];
-    const permission = calculatePermission(sortedBy.data);
-    const queries = useDatapointQueries(hasPermission(permission), sortedBy.data || ServerSortOption.REGISTERED_PLAYERS.data,
+    const allowed = Boolean(servers.length) && hasPermission(calculatePermission(sortedBy.data || ServerSortOption.REGISTERED_PLAYERS.data, {server: servers[0].serverUUID}));
+    const queries = useDatapointQueries(allowed, sortedBy.data || ServerSortOption.REGISTERED_PLAYERS.data,
         servers.map(server => ({
             server: server.serverUUID,
             afterMillisAgo: sortedBy.noFilterDates ? undefined : MS_WEEK
diff --git a/Plan/react/dashboard/src/dataHooks/model/datapoint/Datapoint.ts b/Plan/react/dashboard/src/dataHooks/model/datapoint/Datapoint.ts
@@ -44,6 +44,11 @@ export enum DatapointType {
     TPS_LOW_SPIKES = "TPS_LOW_SPIKES",
 }
 
+export const differingPermissions: Partial<Record<DatapointType, string>> = {
+    PLAYERS_ONLINE: "players.online.current",
+    AFK_TIME_PERCENTAGE: "afk.time"
+}
+
 export type DatapointTypeMap = {
     WORLD_PIE: WorldPie;
     PLAYTIME: number;

Original file line number	Diff line number	Diff line change
`@@ -68,6 +68,9 @@ public Optional<Integer> getValue(GenericFilter filter) {`
`68`	`68`	`serverUUIDs = dbSystem.getDatabase().query(ServerQueries.fetchProxyServerUUIDs());`
`69`	`69`	`}`
`70`	`70`	`}`
	`71`	`+ if (serverUUIDs.isEmpty()) {`
	`72`	`+ return Optional.of(serverSensor.getOnlinePlayerCount());`
	`73`	`+ }`
`71`	`74`
`72`	`75`	`if (serverUUIDs.size() == 1) {`
`73`	`76`	`ServerUUID serverUUID = serverUUIDs.get(0);`
Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ static void savePlayerData(Database database, ServerUUID serverUUID) {`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`static void saveServerData(Database database, ServerUUID serverUUID) {`
`136`		`- RandomData.randomDateOrderedTPS(5).forEach(tps -> database.executeTransaction(new TPSStoreTransaction(serverUUID, tps)).join());`
	`136`	`+ RandomData.randomDateOrderedTPS(1).forEach(tps -> database.executeTransaction(new TPSStoreTransaction(serverUUID, tps)).join());`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`public static List<String> getEndpointsToTest(ServerUUID serverUUID) {`