Add CURRENT_UPTIME datapoint

AuroraLS3 · AuroraLS3 · commit 319e03da0af7 · 2026-04-19T19:43:00.000+03:00
diff --git a/Plan/common/src/main/java/com/djrapitops/plan/delivery/domain/auth/WebPermission.java b/Plan/common/src/main/java/com/djrapitops/plan/delivery/domain/auth/WebPermission.java
@@ -160,6 +160,8 @@ public enum WebPermission implements Supplier<String>, Lang {
     DATA_NETWORK_PLAYERS_ONLINE_PEAK("See Player online peak -datapoint of network"),
     DATA_SERVER_PLAYERS_ONLINE("See Players online -datapoint of servers"),
     DATA_NETWORK_PLAYERS_ONLINE("See Players online -datapoint of network"),
+    DATA_SERVER_CURRENT_UPTIME("See Current uptime -datapoint of servers"),
+    DATA_NETWORK_CURRENT_UPTIME("See Current uptime -datapoint of network"),
     DATA_PLAYER_MOB_KILLS("See Mob kills datapoint of players"),
     DATA_SERVER_MOB_KILLS("See Mob kills datapoint of servers"),
     DATA_NETWORK_MOB_KILLS("See Mob kills datapoint of network"),
diff --git a/Plan/common/src/main/java/com/djrapitops/plan/delivery/export/NetworkPageExporter.java b/Plan/common/src/main/java/com/djrapitops/plan/delivery/export/NetworkPageExporter.java
@@ -160,6 +160,7 @@ public void exportJSON(Path toDirectory, ServerUUID serverUUID) throws IOExcepti
                 datapointType + DatapointType.PLAYER_KILLS,
                 datapointType + DatapointType.MOB_KILLS,
                 datapointType + DatapointType.DEATHS,
+                datapointType + DatapointType.CURRENT_UPTIME,
                 // Week comparison
                 datapointType + DatapointType.UNIQUE_PLAYERS + afterMillis + TimeUnit.DAYS.toMillis(14) + beforeMillis + TimeUnit.DAYS.toMillis(7L),
                 datapointType + DatapointType.NEW_PLAYERS + afterMillis + TimeUnit.DAYS.toMillis(14) + beforeMillis + TimeUnit.DAYS.toMillis(7L),
diff --git a/Plan/common/src/main/java/com/djrapitops/plan/delivery/export/ServerPageExporter.java b/Plan/common/src/main/java/com/djrapitops/plan/delivery/export/ServerPageExporter.java
@@ -167,6 +167,7 @@ public void exportJSON(Path toDirectory, ServerUUID serverUUID) throws IOExcepti
                 datapointType + DatapointType.PLAYER_KILLS + server,
                 datapointType + DatapointType.MOB_KILLS + server,
                 datapointType + DatapointType.DEATHS + server,
+                datapointType + DatapointType.CURRENT_UPTIME + server,
                 // Week comparison
                 datapointType + DatapointType.UNIQUE_PLAYERS + afterMillis + TimeUnit.DAYS.toMillis(14) + beforeMillis + TimeUnit.DAYS.toMillis(7L) + server,
                 datapointType + DatapointType.NEW_PLAYERS + afterMillis + TimeUnit.DAYS.toMillis(14) + beforeMillis + TimeUnit.DAYS.toMillis(7L) + server,
diff --git a/Plan/common/src/main/java/com/djrapitops/plan/delivery/rendering/json/datapoint/DatapointType.java b/Plan/common/src/main/java/com/djrapitops/plan/delivery/rendering/json/datapoint/DatapointType.java
@@ -45,6 +45,7 @@ public enum DatapointType {
     PLAYTIME_PER_PLAYER_AVERAGE(PlaytimePerPlayerAverage.class, DatapointCacheKey.SESSION),
     PLAYERS_ONLINE_PEAK(PlayersOnlinePeak.class, DatapointCacheKey.TPS),
     PLAYERS_ONLINE(PlayersOnline.class, DatapointCacheKey.TPS),
+    CURRENT_UPTIME(CurrentUptime.class),
     MOB_KILLS(MobKills.class, DatapointCacheKey.SESSION),
     PLAYER_KILLS(PlayerKills.class, DatapointCacheKey.SESSION),
     DEATHS(Deaths.class, DatapointCacheKey.SESSION);
diff --git a/Plan/common/src/main/java/com/djrapitops/plan/delivery/rendering/json/datapoint/types/CurrentUptime.java b/Plan/common/src/main/java/com/djrapitops/plan/delivery/rendering/json/datapoint/types/CurrentUptime.java
@@ -0,0 +1,82 @@
+/*
+ *  This file is part of Player Analytics (Plan).
+ *
+ *  Plan is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License v3 as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Plan is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with Plan. If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.djrapitops.plan.delivery.rendering.json.datapoint.types;
+
+import com.djrapitops.plan.delivery.domain.auth.WebPermission;
+import com.djrapitops.plan.delivery.domain.datatransfer.GenericFilter;
+import com.djrapitops.plan.delivery.rendering.json.datapoint.Datapoint;
+import com.djrapitops.plan.delivery.rendering.json.datapoint.DatapointType;
+import com.djrapitops.plan.delivery.web.resolver.exception.BadRequestException;
+import com.djrapitops.plan.gathering.ServerUptimeCalculator;
+import com.djrapitops.plan.identification.ServerInfo;
+import com.djrapitops.plan.identification.ServerUUID;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Datapoint for looking up current uptime of the servers.
+ *
+ * @author AuroraLS3
+ */
+@Singleton
+public class CurrentUptime implements Datapoint<Long> {
+
+    private final ServerInfo serverInfo;
+    private final ServerUptimeCalculator serverUptimeCalculator;
+
+    @Inject
+    public CurrentUptime(ServerInfo serverInfo, ServerUptimeCalculator serverUptimeCalculator) {
+        this.serverInfo = serverInfo;
+        this.serverUptimeCalculator = serverUptimeCalculator;
+    }
+
+    @Override
+    public Optional<Long> getValue(GenericFilter filter) {
+        if (filter.getPlayerUUID().isPresent()) {
+            throw new BadRequestException("CURRENT_UPTIME does not support player parameter");
+        }
+
+        List<ServerUUID> serverUUIDs = filter.getServerUUIDs();
+        ServerUUID serverUUID = serverUUIDs.size() == 1 ? serverUUIDs.get(0) : serverInfo.getServerUUID();
+
+        return serverUptimeCalculator.getServerUptimeMillis(serverUUID);
+    }
+
+    @Override
+    public WebPermission getPermission(GenericFilter filter) {
+        if (filter.getPlayerUUID().isPresent()) {
+            return WebPermission.DATA_PLAYER;
+        } else if (!filter.getServerUUIDs().isEmpty()) {
+            return WebPermission.DATA_SERVER_CURRENT_UPTIME;
+        } else {
+            return WebPermission.DATA_NETWORK_CURRENT_UPTIME;
+        }
+    }
+
+    @Override
+    public DatapointType getType() {
+        return DatapointType.CURRENT_UPTIME;
+    }
+
+    @Override
+    public FormatType getFormatType() {
+        return FormatType.TIME_AMOUNT;
+    }
+}
diff --git a/Plan/common/src/main/java/com/djrapitops/plan/delivery/rendering/json/datapoint/types/DatapointModule.java b/Plan/common/src/main/java/com/djrapitops/plan/delivery/rendering/json/datapoint/types/DatapointModule.java
@@ -96,6 +96,10 @@ public interface DatapointModule {
     @IntoSet
     Datapoint<?> bindPlayersOnline(PlayersOnline playersOnline);
 
+    @Binds
+    @IntoSet
+    Datapoint<?> bindCurrentUptime(CurrentUptime currentUptime);
+
     @Binds
     @IntoSet
     Datapoint<?> bindMobKills(MobKills mobKills);
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
@@ -222,6 +222,9 @@ static Stream<Arguments> testCases() {
                 Arguments.of("/v1/datapoint?type=PLAYERS_ONLINE", WebPermission.DATA_NETWORK_PLAYERS_ONLINE, 200, 403),
                 Arguments.of("/v1/datapoint?type=PLAYERS_ONLINE&server=" + TestConstants.SERVER_UUID_STRING, WebPermission.DATA_SERVER_PLAYERS_ONLINE, 200, 403),
                 Arguments.of("/v1/datapoint?type=PLAYERS_ONLINE&player=" + TestConstants.PLAYER_ONE_UUID_STRING, WebPermission.DATA_PLAYER, 400, 403),
+                Arguments.of("/v1/datapoint?type=CURRENT_UPTIME", WebPermission.DATA_NETWORK_CURRENT_UPTIME, 200, 403),
+                Arguments.of("/v1/datapoint?type=CURRENT_UPTIME&server=" + TestConstants.SERVER_UUID_STRING, WebPermission.DATA_SERVER_CURRENT_UPTIME, 200, 403),
+                Arguments.of("/v1/datapoint?type=CURRENT_UPTIME&player=" + TestConstants.PLAYER_ONE_UUID_STRING, WebPermission.DATA_PLAYER, 400, 403),
                 Arguments.of("/v1/datapoint?type=REGULAR_PLAYERS", WebPermission.DATA_NETWORK_REGULAR_PLAYERS, 200, 403),
                 Arguments.of("/v1/datapoint?type=REGULAR_PLAYERS&server=" + TestConstants.SERVER_UUID_STRING, WebPermission.DATA_SERVER_REGULAR_PLAYERS, 200, 403),
                 Arguments.of("/v1/datapoint?type=REGULAR_PLAYERS&player=" + TestConstants.PLAYER_ONE_UUID_STRING, WebPermission.DATA_PLAYER, 400, 403),
diff --git a/Plan/react/dashboard/src/components/cards/network/QuickViewDataCard.jsx b/Plan/react/dashboard/src/components/cards/network/QuickViewDataCard.jsx
@@ -11,7 +11,7 @@ import {
 } from "@fortawesome/free-solid-svg-icons";
 import {useTranslation} from "react-i18next";
 import Datapoint from "../../datapoint/Datapoint.tsx";
-import CurrentUptime from "../../datapoint/CurrentUptime";
+import CurrentUptime from "../../datapoint/CurrentUptime.tsx";
 import FormattedDate from "../../text/FormattedDate.tsx";
 import FormattedTime from "../../text/FormattedTime.jsx";
 
diff --git a/Plan/react/dashboard/src/components/cards/server/insights/SessionInsightsCard.jsx b/Plan/react/dashboard/src/components/cards/server/insights/SessionInsightsCard.jsx
@@ -44,9 +44,9 @@ const SessionInsightsCard = ({identifier}) => {
                             icon={faClock} color="playtime-afk"
                             dataType={DatapointType.AFK_TIME}
                             filter={filter}
-                            valueLabel={<QueryDatapointValue dataType={DatapointType.AFK_TIME_PERCENTAGE}
-                                                             filter={filter}
-                                                             permission={"afk.time"}/>}
+                            valueLabel={<>(<QueryDatapointValue dataType={DatapointType.AFK_TIME_PERCENTAGE}
+                                                                filter={filter}
+                                                                permission={"afk.time"}/>)</>}
             />
         </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
@@ -7,19 +7,19 @@ import React from "react";
 import {CardLoader} from "../../../navigation/Loader.tsx";
 import ExtendableCardBody from "../../../layout/extension/ExtendableCardBody.tsx";
 import {useMetadata} from "../../../../hooks/metadataHook.tsx";
-import CurrentUptime from "../../../datapoint/CurrentUptime";
+import CurrentUptime from "../../../datapoint/CurrentUptime.tsx";
 import {GenericFilterContextProvider} from "../../../../dataHooks/genericFilterContextHook.tsx";
 import {useParams} from "react-router";
 import {QueryDatapoint} from "../../../datapoint/QueryDatapoint.tsx";
 import {DatapointType} from "../../../../dataHooks/model/datapoint/Datapoint.ts";
 import {MS_24H} from "../../../../util/format/useDateFormatter.js";
 
-const ServerAsNumbersCard = ({data}) => {
+const ServerAsNumbersCard = () => {
     const {t} = useTranslation();
     const {networkMetadata} = useMetadata();
     const {identifier} = useParams();
 
-    if (!data || !networkMetadata) return <CardLoader/>;
+    if (!networkMetadata) return <CardLoader/>;
 
     const isGameServer = !!identifier;
 
@@ -33,8 +33,8 @@ const ServerAsNumbersCard = ({data}) => {
                         </h6>
                     </Card.Header>
                     <ExtendableCardBody
-                        id={data.player_kills === undefined ? 'card-body-network-as-numbers' : 'card-body-server-as-numbers'}>
-                        <CurrentUptime uptime={data.current_uptime}/>
+                        id={isGameServer ? 'card-body-server-as-numbers' : 'card-body-network-as-numbers'}>
+                        <CurrentUptime filter={filter}/>
                         <hr/>
                         <QueryDatapoint name={t('html.label.totalPlayers')}
                                         color={'players-count'} icon={faUsers}
@@ -81,17 +81,14 @@ const ServerAsNumbersCard = ({data}) => {
                         <hr/>
                         <QueryDatapoint name={t('html.label.playerKills')}
                                         color={'player-kills'} icon={faCrosshairs}
-                                        value={data.player_kills}
                                         dataType={DatapointType.PLAYER_KILLS}
                                         filter={filter}/>
                         <QueryDatapoint name={t('html.label.mobKills')}
                                         color={'mob-kills'} icon={faCrosshairs}
-                                        value={data.mob_kills}
                                         dataType={DatapointType.MOB_KILLS}
                                         filter={filter}/>
                         <QueryDatapoint name={t('html.label.deaths')}
                                         color={'deaths'} icon={faSkull}
-                                        value={data.deaths}
                                         dataType={DatapointType.DEATHS}
                                         filter={filter}/>
                     </ExtendableCardBody>
diff --git a/Plan/react/dashboard/src/components/datapoint/CurrentUptime.jsx b/Plan/react/dashboard/src/components/datapoint/CurrentUptime.jsx
diff --git a/Plan/react/dashboard/src/components/datapoint/CurrentUptime.tsx b/Plan/react/dashboard/src/components/datapoint/CurrentUptime.tsx
@@ -0,0 +1,50 @@
+import React from 'react';
+import {useTranslation} from "react-i18next";
+import {faPowerOff} from "@fortawesome/free-solid-svg-icons";
+import {faQuestionCircle} from "@fortawesome/free-regular-svg-icons";
+import Datapoint, {Datapoint as DatapointComponent} from "./Datapoint";
+import {FontAwesomeIcon} from "@fortawesome/react-fontawesome";
+import FormattedTime from "../text/FormattedTime.jsx";
+import {isNumber} from "../../util/isNumber.js";
+import {GenericFilter} from "../../dataHooks/model/GenericFilter";
+import {useAuth} from "../../hooks/authenticationHook";
+import {calculatePermission, useDatapointQuery} from "./QueryDatapoint";
+import {DatapointType} from "../../dataHooks/model/datapoint/Datapoint";
+import {DatapointLoader} from "../navigation/Loader";
+
+type Props = {
+    filter: GenericFilter;
+}
+
+const CurrentUptime = ({filter}: Props) => {
+    const {t} = useTranslation();
+
+    const {hasPermission} = useAuth();
+    const isAllowed = hasPermission(calculatePermission(DatapointType.CURRENT_UPTIME, undefined, filter))
+    const {data, isFetching, error} = useDatapointQuery(isAllowed, DatapointType.CURRENT_UPTIME, filter);
+
+    if (!isAllowed) return null;
+
+    const infoBubble = error?.status === 404
+        ? <span title={t('html.description.noUptimeCalculation')}><FontAwesomeIcon icon={faQuestionCircle}/></span>
+        : undefined;
+
+    if (error && error.status !== 404) {
+        console.error(error);
+        return <DatapointComponent
+            icon={faPowerOff} color={'uptime'}
+            name={t('html.label.currentUptime')}
+            value={error.message}
+        />
+    }
+
+    return (
+        <Datapoint icon={faPowerOff} color={'uptime'}
+                   name={t('html.label.currentUptime')}
+                   value={(data || error?.status === 404) && !isFetching ? (isNumber(data?.value) &&
+                       <FormattedTime timeMs={data?.value}/> || 'plugin.generic.unavailable') : <DatapointLoader/>}
+                   valueLabel={infoBubble}/>
+    )
+};
+
+export default CurrentUptime
diff --git a/Plan/react/dashboard/src/components/datapoint/QueryDatapoint.tsx b/Plan/react/dashboard/src/components/datapoint/QueryDatapoint.tsx
@@ -13,7 +13,7 @@ import {queryRetry} from "../../dataHooks/queryRetry";
 import {useEffect} from "react";
 import {Datapoint as DatapointComponent, DatapointProps} from "./Datapoint";
 import FormattedTime from "../text/FormattedTime";
-import Loader from "../navigation/Loader";
+import {DatapointLoader} from "../navigation/Loader";
 import {useAuth} from "../../hooks/authenticationHook";
 import {useDecimalFormatter} from "../../util/format/useDecimalFormatter";
 import {isOutOf, OutOf} from "../../dataHooks/model/datapoint/OutOf";
@@ -97,7 +97,7 @@ export function calculatePermission(dataType: DatapointType, permission?: string
 export function QueryDatapoint<K extends DatapointType>({permission, dataType, filter, ...props}: Props<K>) {
     const {hasPermission} = useAuth();
     const allowed = hasPermission(calculatePermission(dataType, permission, filter));
-    const {data, error} = useDatapointQuery(allowed, dataType, filter);
+    const {data, isFetching, error} = useDatapointQuery(allowed, dataType, filter);
 
     if (!allowed) return null;
     if (error) {
@@ -108,30 +108,28 @@ export function QueryDatapoint<K extends DatapointType>({permission, dataType, f
         />
     }
 
-    const cast = data as Datapoint<K>;
-
-    const name = cast && isDateObj(cast.value) ? <>{props.name} (<FormattedDate
-        date={(cast.value as DateObj).date}/>)</> : props.name
+    const name = data && isDateObj(data.value) ? <>{props.name} (<FormattedDate
+        date={(data.value as DateObj).date}/>)</> : props.name
 
     return <DatapointComponent
         {...props}
         name={name}
-        value={cast ? <Format value={cast.value} formatType={cast.formatType}/> : <Loader/>}
+        value={data && !isFetching ? <Format value={data.value} formatType={data.formatType}/> : <DatapointLoader/>}
     />
 }
 
 export function QueryDatapointValue<K extends DatapointType>({permission, dataType, filter}: ValueProps<K>) {
     const {hasPermission} = useAuth();
     const allowed = hasPermission(calculatePermission(dataType, permission, filter));
-    const {data, error} = useDatapointQuery(allowed, dataType, filter);
+    const {data, isFetching, error} = useDatapointQuery(allowed, dataType, filter);
 
     if (!allowed) return null;
     if (error) {
         console.error(error);
         return error.message;
     }
 
-    return data ? <Format value={data.value} formatType={data.formatType}/> : <Loader/>
+    return data && !isFetching ? <Format value={data.value} formatType={data.formatType}/> : <DatapointLoader/>
 }
 
 type TrendProps<K extends NumericDatapointType> = { downGood?: boolean, filter2: GenericFilter } & ValueProps<K>
@@ -163,12 +161,12 @@ export function QueryDatapointTrend<K extends NumericDatapointType>({
             text: before.value - after.value,
             reversed: downGood,
             direction: before.value - after.value === 0 ? undefined : (before.value - after.value > 0 ? '+' : '-')
-        }} format={(value: number) => <Format value={value}/>}/>
-        : <Loader/>
+        }} format={(value: number) => <Format value={value} formatType={before.formatType}/>}/>
+        : <DatapointLoader/>
 }
 
 
-function useDatapointQuery<K extends DatapointType>(allowed: boolean, dataType: K, filter?: GenericFilter) {
+export function useDatapointQuery<K extends DatapointType>(allowed: boolean, dataType: K, filter?: GenericFilter) {
     const {updateRequested} = useNavigation() as { updateRequested: number };
     const query = useQuery({
         queryKey: filter ? ['datapoint', dataType, ...Object.values(filter)] : ['datapoint', dataType],
diff --git a/Plan/react/dashboard/src/components/navigation/Loader.tsx b/Plan/react/dashboard/src/components/navigation/Loader.tsx
@@ -30,4 +30,10 @@ const Loader = () => {
     )
 }
 
+export const DatapointLoader = () => {
+    return (
+        <div className="datapoint-loader"/>
+    )
+}
+
 export default Loader;
diff --git a/Plan/react/dashboard/src/dataHooks/model/datapoint/Datapoint.ts b/Plan/react/dashboard/src/dataHooks/model/datapoint/Datapoint.ts
@@ -22,6 +22,7 @@ export enum DatapointType {
     REGULAR_PLAYERS = "REGULAR_PLAYERS",
     PLAYERS_ONLINE = "PLAYERS_ONLINE",
     PLAYERS_ONLINE_PEAK = "PLAYERS_ONLINE_PEAK",
+    CURRENT_UPTIME = "CURRENT_UPTIME",
     SESSION_COUNT = "SESSION_COUNT",
     SESSION_LENGTH_AVERAGE = "SESSION_LENGTH_AVERAGE",
     PLAYTIME_PER_PLAYER_AVERAGE = "PLAYTIME_PER_PLAYER_AVERAGE",
@@ -39,6 +40,7 @@ export type DatapointTypeMap = {
     NEW_PLAYERS: number;
     REGULAR_PLAYERS: number;
     PLAYERS_ONLINE: number;
+    CURRENT_UPTIME: number;
     SESSION_COUNT: number;
     SESSION_LENGTH_AVERAGE: number;
     PLAYTIME_PER_PLAYER_AVERAGE: number;
diff --git a/Plan/react/dashboard/src/style/style.css b/Plan/react/dashboard/src/style/style.css
diff --git a/Plan/react/dashboard/src/views/network/NetworkOverview.jsx b/Plan/react/dashboard/src/views/network/NetworkOverview.jsx
diff --git a/Plan/react/dashboard/src/views/server/ServerOverview.jsx b/Plan/react/dashboard/src/views/server/ServerOverview.jsx
