Add PLAYTIME_PER_PLAYER_AVERAGE datapoint

Author: AuroraLS3

Plan/common/src/main/java/com/djrapitops/plan/delivery/domain/auth/WebPermission.java

@@ -154,6 +154,8 @@ public enum WebPermission implements Supplier<String>, Lang {
     DATA_PLAYER_SESSION_LENGTH_AVERAGE("See Average session length datapoint of players"),
     DATA_SERVER_SESSION_LENGTH_AVERAGE("See Average session length datapoint of servers"),
     DATA_NETWORK_SESSION_LENGTH_AVERAGE("See Average session length datapoint of network"),
+    DATA_SERVER_PLAYTIME_PER_PLAYER_AVERAGE("See Average playtime per player datapoint of servers"),
+    DATA_NETWORK_PLAYTIME_PER_PLAYER_AVERAGE("See Average playtime per player datapoint of network"),
     DATA_SERVER_PLAYERS_ONLINE_PEAK("See Player online peak -datapoint of servers"),
     DATA_NETWORK_PLAYERS_ONLINE_PEAK("See Player online peak -datapoint of network"),
 

Plan/common/src/main/java/com/djrapitops/plan/delivery/rendering/json/datapoint/DatapointType.java

@@ -42,6 +42,7 @@ public enum DatapointType {
     REGULAR_PLAYERS(RegularPlayers.class, DatapointCacheKey.SESSION),
     SESSION_COUNT(SessionCount.class, DatapointCacheKey.SESSION),
     SESSION_LENGTH_AVERAGE(SessionLengthAverage.class, DatapointCacheKey.SESSION),
+    PLAYTIME_PER_PLAYER_AVERAGE(PlaytimePerPlayerAverage.class, DatapointCacheKey.SESSION),
     PLAYERS_ONLINE_PEAK(PlayersOnlinePeak.class, DatapointCacheKey.TPS);
 
     private final Class<? extends Datapoint<?>> datapointClass;

Plan/common/src/main/java/com/djrapitops/plan/delivery/rendering/json/datapoint/types/DatapointModule.java

@@ -80,6 +80,10 @@ public interface DatapointModule {
     @IntoSet
     Datapoint<?> bindSessionLengthAverage(SessionLengthAverage sessionLengthAverage);
 
+    @Binds
+    @IntoSet
+    Datapoint<?> bindPlaytimePerPlayerAverage(PlaytimePerPlayerAverage playtimePerPlayerAverage);
+
     @Binds
     @IntoSet
     Datapoint<?> bindPlayerOnlinePeak(PlayersOnlinePeak playersOnlinePeak);

Plan/common/src/main/java/com/djrapitops/plan/delivery/rendering/json/datapoint/types/PlaytimePerPlayerAverage.java

@@ -0,0 +1,83 @@
+/*
+ *  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.identification.ServerUUID;
+import com.djrapitops.plan.storage.database.DBSystem;
+import com.djrapitops.plan.storage.database.Database;
+import com.djrapitops.plan.storage.database.queries.objects.SessionQueries;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * Datapoint for average playtime per player.
+ *
+ * @author AuroraLS3
+ */
+@Singleton
+public class PlaytimePerPlayerAverage implements Datapoint<Long> {
+
+    private final DBSystem dbSystem;
+
+    @Inject
+    public PlaytimePerPlayerAverage(DBSystem dbSystem) {
+        this.dbSystem = dbSystem;
+    }
+
+    @Override
+    public DatapointType getType() {
+        return DatapointType.PLAYTIME_PER_PLAYER_AVERAGE;
+    }
+
+    @Override
+    public FormatType getFormatType() {
+        return FormatType.TIME_AMOUNT;
+    }
+
+    @Override
+    public WebPermission getPermission(GenericFilter filter) {
+        if (filter.getPlayerUUID().isPresent()) {
+            return WebPermission.DATA_PLAYER;
+        } else if (!filter.getServerUUIDs().isEmpty()) {
+            return WebPermission.DATA_SERVER_PLAYTIME_PER_PLAYER_AVERAGE;
+        } else {
+            return WebPermission.DATA_NETWORK_PLAYTIME_PER_PLAYER_AVERAGE;
+        }
+    }
+
+    @Override
+    public Optional<Long> getValue(GenericFilter filter) {
+        if (filter.getPlayerUUID().isPresent()) {
+            throw new BadRequestException("PLAYTIME_PER_PLAYER_AVERAGE does not support player parameter");
+        }
+        Database db = dbSystem.getDatabase();
+
+        List<ServerUUID> serverUUIDs = filter.getServerUUIDs();
+
+        // This does not include active sessions
+        // because merging active sessions to the average would produce more rows in SQL query.
+        return Optional.of(db.query(SessionQueries.averagePlaytimePerPlayer(filter.getAfter(), filter.getBefore(), serverUUIDs)));
+    }
+}

Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/SessionQueries.java

@@ -760,16 +760,18 @@ public Long processResults(ResultSet set) throws SQLException {
         };
     }
 
-    public static Query<Long> averagePlaytimePerPlayer(long after, long before, ServerUUID serverUUID) {
+    public static Query<Long> averagePlaytimePerPlayer(long after, long before, List<ServerUUID> serverUUIDs) {
+        if (serverUUIDs.isEmpty()) {
+            return averagePlaytimePerPlayer(after, before);
+        }
         return db -> {
             String selectPlaytimePerPlayer = SELECT +
                     SessionsTable.USER_ID + "," +
                     playtimeColumn(db.getSql(), after, before) +
                     FROM + SessionsTable.TABLE_NAME + " t" +
-                    INNER_JOIN + ServerTable.TABLE_NAME + " s ON s." + ServerTable.ID + "=t." + SessionsTable.SERVER_ID +
                     WHERE + SessionsTable.SESSION_START + "<=?" +
                     AND + SessionsTable.SESSION_END + ">=?" +
-                    AND + "s." + ServerTable.SERVER_UUID + "=?" +
+                    AND + SessionsTable.SERVER_ID + " IN " + ServerTable.selectServerIds(serverUUIDs) +
                     GROUP_BY + SessionsTable.USER_ID;
             String selectAverage = SELECT + "AVG(playtime) as average" + FROM + '(' + selectPlaytimePerPlayer + ") q1";
 
@@ -778,7 +780,6 @@ public static Query<Long> averagePlaytimePerPlayer(long after, long before, Serv
                 public void prepare(PreparedStatement statement) throws SQLException {
                     statement.setLong(1, before);
                     statement.setLong(2, after);
-                    statement.setString(3, serverUUID.toString());
                 }
 
                 @Override
@@ -789,6 +790,10 @@ public Long processResults(ResultSet set) throws SQLException {
         };
     }
 
+    public static Query<Long> averagePlaytimePerPlayer(long after, long before, ServerUUID serverUUID) {
+        return averagePlaytimePerPlayer(after, before, Collections.singletonList(serverUUID));
+    }
+
     /**
      * Fetch average playtime per ALL players.
      *

Plan/common/src/test/java/com/djrapitops/plan/delivery/webserver/AccessControlTest.java

@@ -213,6 +213,9 @@ static Stream<Arguments> testCases() {
                 Arguments.of("/v1/datapoint?type=SESSION_LENGTH_AVERAGE", WebPermission.DATA_NETWORK_SESSION_LENGTH_AVERAGE, 200, 403),
                 Arguments.of("/v1/datapoint?type=SESSION_LENGTH_AVERAGE&server=" + TestConstants.SERVER_UUID_STRING, WebPermission.DATA_SERVER_SESSION_LENGTH_AVERAGE, 200, 403),
                 Arguments.of("/v1/datapoint?type=SESSION_LENGTH_AVERAGE&player=" + TestConstants.PLAYER_ONE_UUID_STRING, WebPermission.DATA_PLAYER_SESSION_LENGTH_AVERAGE, 200, 403),
+                Arguments.of("/v1/datapoint?type=PLAYTIME_PER_PLAYER_AVERAGE", WebPermission.DATA_NETWORK_PLAYTIME_PER_PLAYER_AVERAGE, 200, 403),
+                Arguments.of("/v1/datapoint?type=PLAYTIME_PER_PLAYER_AVERAGE&server=" + TestConstants.SERVER_UUID_STRING, WebPermission.DATA_SERVER_PLAYTIME_PER_PLAYER_AVERAGE, 200, 403),
+                Arguments.of("/v1/datapoint?type=PLAYTIME_PER_PLAYER_AVERAGE&player=" + TestConstants.PLAYER_ONE_UUID_STRING, WebPermission.DATA_PLAYER, 400, 403),
                 Arguments.of("/v1/datapoint?type=PLAYERS_ONLINE_PEAK", WebPermission.DATA_NETWORK_PLAYERS_ONLINE_PEAK, 200, 403),
                 Arguments.of("/v1/datapoint?type=PLAYERS_ONLINE_PEAK&server=" + TestConstants.SERVER_UUID_STRING, WebPermission.DATA_SERVER_PLAYERS_ONLINE_PEAK, 200, 403),
                 Arguments.of("/v1/datapoint?type=PLAYERS_ONLINE_PEAK&player=" + TestConstants.PLAYER_ONE_UUID_STRING, WebPermission.DATA_PLAYER, 400, 403),

Plan/react/dashboard/src/dataHooks/model/datapoint/Datapoint.ts

@@ -23,6 +23,7 @@ export enum DatapointType {
     PLAYERS_ONLINE_PEAK = "PLAYERS_ONLINE_PEAK",
     SESSION_COUNT = "SESSION_COUNT",
     SESSION_LENGTH_AVERAGE = "SESSION_LENGTH_AVERAGE",
+    PLAYTIME_PER_PLAYER_AVERAGE = "PLAYTIME_PER_PLAYER_AVERAGE",
 }
 
 export type DatapointTypeMap = {
@@ -35,6 +36,7 @@ export type DatapointTypeMap = {
     REGULAR_PLAYERS: number;
     SESSION_COUNT: number;
     SESSION_LENGTH_AVERAGE: number;
+    PLAYTIME_PER_PLAYER_AVERAGE: number;
     SERVER_OCCUPIED: OutOf;
     MOST_ACTIVE_WORLD: OutOfCategory;
     MOST_ACTIVE_GAME_MODE: OutOfCategory;