app/src/main/kotlin/xyz/etztech/stonks/App.kt

@@ -4,7 +4,6 @@ import com.natpryce.konfig.*
 import java.io.FileInputStream
 import java.util.*
 import kotlinx.coroutines.*
-import kotlinx.serialization.*
 import org.h2.tools.Server
 import org.jetbrains.exposed.exceptions.ExposedSQLException
 import org.jetbrains.exposed.sql.*
@@ -12,7 +11,6 @@ import org.jetbrains.exposed.sql.transactions.TransactionManager
 import org.jetbrains.exposed.sql.transactions.transaction
 import xyz.etztech.stonks.api.initApiServer
 import xyz.etztech.stonks.dsl.AggregateStatistics
-import xyz.etztech.stonks.dsl.KeyValue
 import xyz.etztech.stonks.dsl.LiveStatistics
 import xyz.etztech.stonks.dsl.Players
 import xyz.etztech.stonks.dsl.Statistics
@@ -93,7 +91,6 @@ fun initH2Server(
         SchemaUtils.create(LiveStatistics)
         SchemaUtils.create(AggregateStatistics)
         SchemaUtils.create(Players)
-        SchemaUtils.create(KeyValue)
 
         // Create indexes with explicit SQL because I can't figure out how to do it with exposed
         // Wrap it in a try block because it throws an exception if index already exists
@@ -116,32 +113,6 @@ fun initH2Server(
             TransactionManager.current()
                     .exec("CREATE INDEX idx_type_name ON LiveStatistics (\"Type\", \"Name\")")
         } catch (e: ExposedSQLException) {}
-
-        val schemaVersions =
-                KeyValue.slice(KeyValue.value).select { KeyValue.key.eq("SchemaVersion") }.map {
-                    it[KeyValue.value]
-                }
-        val schemaVersion = if (schemaVersions.count() > 0) schemaVersions.single() else 0
-        println("Database schemaVersion = ${schemaVersion}")
-
-        if (schemaVersion < 1) {
-            println("Migrating database to schemaVersion 1.")
-
-            TransactionManager.current().exec("TRUNCATE TABLE AGGREGATESTATISTICS")
-
-            KeyValue.insert {
-                it[KeyValue.key] = "SchemaVersion"
-                it[KeyValue.value] = 1
-            }
-        }
-
-        if (schemaVersion < 2) {
-            println("Migrating database to schemaVersion 2.")
-
-            TransactionManager.current().exec("TRUNCATE TABLE AGGREGATESTATISTICS")
-
-            KeyValue.update({ KeyValue.key eq "SchemaVersion" }) { it[KeyValue.value] = 2 }
-        }
     }
 
     return database

app/src/main/kotlin/xyz/etztech/stonks/DSL.kt

@@ -41,10 +41,3 @@ object Players : Table() {
 
     override val primaryKey = PrimaryKey(id, name = "PK_id")
 }
-
-object KeyValue : Table() {
-    val key: Column<String> = varchar("Key", 150)
-    val value: Column<Int> = integer("Value")
-
-    override val primaryKey = PrimaryKey(key, name = "PK_key")
-}

app/src/main/kotlin/xyz/etztech/stonks/StatisticsImporter.kt

@@ -65,6 +65,8 @@ object StatisticsImporter {
                     }
         }
         transaction(database) {
+            addLogger(StdOutSqlLogger)
+
             statsFile?.stats?.forEach { type, stats ->
                 stats.forEach { name, value ->
                     if (playerStats.get(type)?.get(name) != value) {
@@ -132,53 +134,29 @@ object StatisticsImporter {
                             SET @Timestamp = CURRENT_TIMESTAMP;
 
                             INSERT INTO AGGREGATESTATISTICS ("Type", "Name", "Timestamp", "Value")
-                            SELECT LiveMax."Type",
+                            SELECT Live."Type",
                                    '',
                                    @Timestamp AS "Timestamp",
-                                   SUM(LiveMax."Value")
+                                   sum(Live."Value")
-                            FROM (
+                            FROM LIVESTATISTICS as Live
-                                SELECT Live."Type",
+                                LEFT JOIN AGGREGATESTATISTICS as Agg
-                                       Live."Name",
+                                    ON Live."Type" = Agg."Type"
-                                       MAX(Live."Value") AS "Value"
+                            WHERE array_contains(array['minecraft:mined'], Live."Type")
-                                FROM livestatistics as Live
+                            GROUP BY Live."Type"
-                                WHERE array_contains(array['minecraft:mined'], Live."Type")
+                            HAVING sum(Live."Value") <> max(Agg."Value") OR max(Agg."Value") IS NULL;
-                                GROUP BY Live."Type", Live."Name", Live."PlayerId"
-                            ) as LiveMax
-                            LEFT JOIN (
-                                    SELECT AGGREGATESTATISTICS."Type",
-                                           AGGREGATESTATISTICS."Name",
-                                           MAX(AGGREGATESTATISTICS."Value") as "Value"
-                                    FROM AGGREGATESTATISTICS
-                                    GROUP BY AGGREGATESTATISTICS."Type", AGGREGATESTATISTICS."Name"
-                                ) as Agg
-                                ON LiveMax."Type" = Agg."Type"
-                            GROUP BY LiveMax."Type"
-                            HAVING sum(LiveMax."Value") <> max(Agg."Value") OR max(Agg."Value") IS NULL;
                             
                             INSERT INTO AGGREGATESTATISTICS ("Type", "Name", "Timestamp", "Value")
-                            SELECT LiveMax."Type",
+                            SELECT Live."Type",
-                                   LiveMax."Name",
+                                   Live."Name",
                                    @Timestamp AS "Timestamp",
-                                   SUM(LiveMax."Value")
+                                   Sum(Live."Value")
-                            FROM (
+                            FROM livestatistics as Live
-                                SELECT Live."Type",
+                                LEFT JOIN AGGREGATESTATISTICS as Agg
-                                       Live."Name",
+                                    ON Live."Type" = Agg."Type" AND Live."Name" = Agg."Name"
-                                       MAX(Live."Value") AS "Value"
+                            WHERE array_contains(array['minecraft:animals_bred', 'minecraft:play_one_minute', 'minecraft:deaths', 'minecraft:player_kills', 'minecraft:aviate_one_cm', 'minecraft:boat_one_cm', 'minecraft:crouch_one_cm', 'minecraft:horse_one_cm', 'minecraft:minecart_one_cm', 'minecraft:sprint_one_cm', 'minecraft:strider_one_cm', 'minecraft:swim_one_cm', 'minecraft:walk_on_water_one_cm', 'minecraft:walk_one_cm', 'minecraft:walk_under_water_one_cm' ], Live."Name")
-                                FROM livestatistics as Live
+OR array_contains(array['minecraft:killed', 'minecraft:killed_by'], Live."Type")
-                                WHERE array_contains(array['minecraft:animals_bred', 'minecraft:play_one_minute', 'minecraft:deaths', 'minecraft:player_kills', 'minecraft:aviate_one_cm', 'minecraft:boat_one_cm', 'minecraft:crouch_one_cm', 'minecraft:horse_one_cm', 'minecraft:minecart_one_cm', 'minecraft:sprint_one_cm', 'minecraft:strider_one_cm', 'minecraft:swim_one_cm', 'minecraft:walk_on_water_one_cm', 'minecraft:walk_one_cm', 'minecraft:walk_under_water_one_cm' ], Live."Name")
+                            GROUP BY Live."Type", Live."Name"
-                                        OR array_contains(array['minecraft:killed', 'minecraft:killed_by'], Live."Type")
+                            HAVING sum(Live."Value") <> max(Agg."Value") OR max(Agg."Value") IS NULL;
-                                GROUP BY Live."Type", Live."Name", Live."PlayerId"
-                            ) as LiveMax
-                            LEFT JOIN (
-                                    SELECT AGGREGATESTATISTICS."Type",
-                                           AGGREGATESTATISTICS."Name",
-                                           MAX(AGGREGATESTATISTICS."Value") as "Value"
-                                    FROM AGGREGATESTATISTICS
-                                    GROUP BY AGGREGATESTATISTICS."Type", AGGREGATESTATISTICS."Name"
-                                ) as Agg
-                                ON LiveMax."Type" = Agg."Type" AND LiveMax."Name" = Agg."Name"
-                            GROUP BY LiveMax."Type", LiveMax."Name"
-                            HAVING SUM(LiveMax."Value") <> MAX(Agg."Value") OR MAX(Agg."Value") IS NULL;
                     """.trimIndent()
                     )
         }
@@ -202,7 +180,7 @@ object StatisticsImporter {
                             .map { it[LiveStatistics.playerId] }
 
             savedPlayers
-                    .filter { Duration.between(it.timestamp, Instant.now()) > Duration.ofDays(1) }
+                    .filter { Duration.between(Instant.now(), it.timestamp) > Duration.ofDays(1) }
                     .forEach { player ->
                         runBlocking {
                             val name = getName(player.id)

spa/src/AggregatesShowcase.js

@@ -2,43 +2,59 @@ import React from "react";
 import { useQuery } from "react-query";
 import axios from "axios";
 
-import { SimpleGrid, Stat, StatLabel, StatNumber } from "@chakra-ui/react";
+import {
+  AspectRatio,
+  Box,
+  Flex,
+  Heading,
+  HStack,
+  Icon,
+  SimpleGrid,
+  Stat,
+  StatLabel,
+  StatNumber,
+  StatHelpText,
+  StatArrow,
+  StatGroup,
+  Tooltip,
+} from "@chakra-ui/react";
+import { FaUserCircle, FaArrowAltCircleRight } from "react-icons/fa";
+import { Link } from "react-router-dom";
+import { AutoSizer, WindowScroller, List } from "react-virtualized";
 import prettifyStatisticName from "./PrettifyStatisticName";
 import StackedBar from "./StackedBar";
 
 const AggregatesShowcase = () => {
-  const aggregates = useQuery(`aggregates`, async () => {
+  const aggregates = useQuery(
-    const { data } = await axios.get(`/api/aggregates`);
+    `aggregates`,
-    return data;
+    async () => {
-  });
+      const { data } = await axios.get(`http://localhost:7000/api/aggregates`);
+      return data;
+    },
+    {
+      placeholderData: [],
+    }
+  );
 
-  const killedAggregates = aggregates.isSuccess
+  const killedAggregates = aggregates.data
-    ? aggregates.data
+    .filter((x) => x.type === "minecraft:killed")
-        .filter((x) => x.type === "minecraft:killed")
+    .sort((a, b) => b.value - a.value);
-        .sort((a, b) => b.value - a.value)
+  const killedTotal = killedAggregates.reduce((acc, val) => acc + val.value, 0);
-    : [];
-  // const killedTotal = killedAggregates.reduce((acc, val) => acc + val.value, 0);
 
-  const killedByAggregates = aggregates.isSuccess
+  const killedByAggregates = aggregates.data
-    ? aggregates.data
+    .filter((x) => x.type === "minecraft:killed_by")
-        .filter((x) => x.type === "minecraft:killed_by")
+    .sort((a, b) => b.value - a.value);
-        .sort((a, b) => b.value - a.value)
+  const killedByTotal = killedByAggregates.reduce(
-    : [];
+    (acc, val) => acc + val.value,
-  // const killedByTotal = killedByAggregates.reduce(
+    0
-  //   (acc, val) => acc + val.value,
+  );
-  //   0
-  // );
 
-  const travelAggregates = aggregates.isSuccess
+  const travelAggregates = aggregates.data
-    ? aggregates.data
+    .filter((x) => x.type === "minecraft:custom" && x.name.endsWith("one_cm"))
-        .filter(
+    .sort((a, b) => b.value - a.value);
-          (x) => x.type === "minecraft:custom" && x.name.endsWith("one_cm")
+  const travelTotal = travelAggregates.reduce((acc, val) => acc + val.value, 0);
-        )
-        .sort((a, b) => b.value - a.value)
-    : [];
-  // const travelTotal = travelAggregates.reduce((acc, val) => acc + val.value, 0);
 
-  return aggregates.isSuccess ? (
+  return aggregates.isFetched ? (
     <>
       <StackedBar heading="Mobs Killed" aggregates={killedAggregates} />
 
@@ -57,15 +73,18 @@ const AggregatesShowcase = () => {
           .map((x, i) => {
             var value = x.value;
             if (x.name === "minecraft:play_one_minute") {
-              value = Math.floor(x.value / 20 / 60);
+              value = x.value / 20 / 60;
             }
 
             return (
               <Stat key={i}>
                 <StatLabel>{prettifyStatisticName(x.type, x.name)}</StatLabel>
-                <StatNumber>{`${value
+                <StatNumber>{`${x.value
                   .toString()
-                  .replace(/\B(?=(\d{3})+(?!\d))/g, ",")}`}</StatNumber>
+                  .replace(
+                    /\B(?<!\.\d*)(?=(\d{3})+(?!\d))/g,
+                    ","
+                  )}`}</StatNumber>
               </Stat>
             );
           })}

spa/src/App.js

@@ -41,17 +41,14 @@ const App = () => {
               <Statistic
                 type={routeProps.match.params.type}
                 name={routeProps.match.params.name}
-                players={players.data}
+                players={players}
               />
             )}
           />
           <Route
             path="/player/:id"
             render={(routeProps) => (
-              <Player
+              <Player playerId={routeProps.match.params.id} players={players} />
-                playerId={routeProps.match.params.id}
-                players={players.data}
-              />
             )}
           />
           <Route>

spa/src/Player.js

@@ -16,13 +16,19 @@ import { Link } from "react-router-dom";
 import prettifyStatisticName from "./PrettifyStatisticName";
 
 const Player = ({ playerId, players }) => {
-  const playerStats = useQuery(`player ${playerId}`, async () => {
+  const playerStats = useQuery(
-    const { data } = await axios.get(`/api/players/${playerId}`);
+    `player ${playerId}`,
-    data.sort((a, b) => a.rank - b.rank || b.value - a.value);
+    async () => {
-    return data.filter((x) => x.value > 0);
+      const { data } = await axios.get(`/api/players/${playerId}`);
-  });
+      data.sort((a, b) => a.rank - b.rank);
+      return data;
+    },
+    {
+      placeholderData: [],
+    }
+  );
 
-  const playerName = players?.find((x) => x.id === playerId)?.name;
+  const playerName = players.data.find((x) => x.id === playerId)?.name;
 
   return (
     <>
@@ -54,23 +60,19 @@ const Player = ({ playerId, players }) => {
           </Tr>
         </Thead>
         <Tbody>
-          {playerStats.isSuccess ? (
+          {playerStats.data.map((x, i) => {
-            playerStats.data.map((x, i) => {
+            return (
-              return (
+              <Tr key={i}>
-                <Tr key={i}>
+                <Td>
-                  <Td>
+                  <Link to={`/statistic/${x.type}/${x.name}`}>
-                    <Link to={`/statistic/${x.type}/${x.name}`}>
+                    {prettifyStatisticName(x.type, x.name)}
-                      {prettifyStatisticName(x.type, x.name)}
+                  </Link>
-                    </Link>
+                </Td>
-                  </Td>
+                <Td isNumeric>{x.rank}</Td>
-                  <Td isNumeric>{x.rank}</Td>
+                <Td isNumeric>{x.value}</Td>
-                  <Td isNumeric>{x.value}</Td>
+              </Tr>
-                </Tr>
+            );
-              );
+          })}
-            })
-          ) : (
-            <></>
-          )}
         </Tbody>
       </Table>
     </>

spa/src/StackedBar.js

@@ -1,6 +1,21 @@
 import React, { useMemo } from "react";
 import useHover from "./useHover";
-import { Box, Heading, HStack, Tooltip } from "@chakra-ui/react";
+import {
+  AspectRatio,
+  Box,
+  Button,
+  Heading,
+  HStack,
+  Icon,
+  Input,
+  Stat,
+  StatLabel,
+  StatNumber,
+  StatHelpText,
+  StatArrow,
+  StatGroup,
+  Tooltip,
+} from "@chakra-ui/react";
 import prettifyStatisticName from "./PrettifyStatisticName";
 
 const randomColor = () =>
@@ -18,15 +33,15 @@ const StackedBarSegment = ({ aggregate, total }) => {
       hasArrow
       label={`${aggregate.value
         .toString()
-        .replace(/\B(?=(\d{3})+(?!\d))/g, ",")} ${prettifyStatisticName(
+        .replace(
-        aggregate.type,
+          /\B(?<!\.\d*)(?=(\d{3})+(?!\d))/g,
-        aggregate.name
+          ","
-      )}`}
+        )} ${prettifyStatisticName(aggregate.type, aggregate.name)}`}
     >
       <Box
         width={aggregate.value / total}
         height="100%"
-        filter={isHovered ? "clear" : "saturate(0.5)"}
+        filter={isHovered ? "clear" : "saturate(0.15)"}
         backgroundColor={color}
         ref={hoverRef}
       ></Box>

spa/src/Statistic.js

@@ -15,13 +15,19 @@ import { Link } from "react-router-dom";
 import prettifyStatisticName from "./PrettifyStatisticName";
 
 const Statistic = ({ type, name, players }) => {
-  const ranking = useQuery(`statistic ${type} ${name}`, async () => {
+  const ranking = useQuery(
-    const { data } = await axios.get(`/api/statistics/${type}/${name}`);
+    `statistic ${type} ${name}`,
-    return data.filter((x) => x.value > 0);
+    async () => {
-  });
+      const { data } = await axios.get(`/api/statistics/${type}/${name}`);
+      return data;
+    },
+    {
+      placeholderData: [],
+    }
+  );
 
   const playerDict = useMemo(() => {
-    return Object.assign({}, ...players.map((x) => ({ [x.id]: x.name })));
+    return Object.assign({}, ...players.data.map((x) => ({ [x.id]: x.name })));
   }, [players]);
 
   return (
@@ -46,23 +52,19 @@ const Statistic = ({ type, name, players }) => {
           </Tr>
         </Thead>
         <Tbody>
-          {ranking.isSuccess ? (
+          {ranking.data.map((x, i) => {
-            ranking.data.map((x, i) => {
+            return (
-              return (
+              <Tr key={i}>
-                <Tr key={i}>
+                <Td>
-                  <Td>
+                  <Link to={`/player/${x.playerId}`}>
-                    <Link to={`/player/${x.playerId}`}>
+                    {playerDict[x.playerId]}
-                      {playerDict[x.playerId]}
+                  </Link>
-                    </Link>
+                </Td>
-                  </Td>
+                <Td isNumeric>{x.rank}</Td>
-                  <Td isNumeric>{x.rank}</Td>
+                <Td isNumeric>{x.value}</Td>
-                  <Td isNumeric>{x.value}</Td>
+              </Tr>
-                </Tr>
+            );
-              );
+          })}
-            })
-          ) : (
-            <></>
-          )}
         </Tbody>
       </Table>
     </>

spa/src/useHover.js

@@ -1,4 +1,4 @@
-import { useEffect, useRef, useState } from "react";
+import React, { useEffect, useRef, useState } from "react";
 
 function useHover() {
   const [value, setValue] = useState(false);
@@ -16,8 +16,8 @@ function useHover() {
           node.removeEventListener("mouseout", handleMouseOut);
         };
       }
-    } //,
+    },
-    //[ref.current] // Recall only if ref changes
+    [ref.current] // Recall only if ref changes
   );
   return [ref, value];
 }