Improve error handling - just display nothing

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

@@ -4,6 +4,7 @@ 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.*
@@ -11,6 +12,7 @@ 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
@@ -91,6 +93,7 @@ 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
@@ -113,6 +116,32 @@ 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,3 +41,10 @@ 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,8 +65,6 @@ object StatisticsImporter {
                     }
         }
         transaction(database) {
-            addLogger(StdOutSqlLogger)
-
             statsFile?.stats?.forEach { type, stats ->
                 stats.forEach { name, value ->
                     if (playerStats.get(type)?.get(name) != value) {
@@ -134,29 +132,53 @@ object StatisticsImporter {
                             SET @Timestamp = CURRENT_TIMESTAMP;
 
                             INSERT INTO AGGREGATESTATISTICS ("Type", "Name", "Timestamp", "Value")
-                            SELECT Live."Type",
+                            SELECT LiveMax."Type",
                                    '',
                                    @Timestamp AS "Timestamp",
-                                   sum(Live."Value")
-                            FROM LIVESTATISTICS as Live
-                                LEFT JOIN AGGREGATESTATISTICS as Agg
-                                    ON Live."Type" = Agg."Type"
-                            WHERE array_contains(array['minecraft:mined'], Live."Type")
-                            GROUP BY Live."Type"
-                            HAVING sum(Live."Value") <> max(Agg."Value") OR max(Agg."Value") IS NULL;
+                                   SUM(LiveMax."Value")
+                            FROM (
+                                SELECT Live."Type",
+                                       Live."Name",
+                                       MAX(Live."Value") AS "Value"
+                                FROM livestatistics as Live
+                                WHERE array_contains(array['minecraft:mined'], Live."Type")
+                                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 Live."Type",
-                                   Live."Name",
+                            SELECT LiveMax."Type",
+                                   LiveMax."Name",
                                    @Timestamp AS "Timestamp",
-                                   Sum(Live."Value")
-                            FROM livestatistics as Live
-                                LEFT JOIN AGGREGATESTATISTICS as Agg
-                                    ON Live."Type" = Agg."Type" AND Live."Name" = Agg."Name"
-                            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")
-OR array_contains(array['minecraft:killed', 'minecraft:killed_by'], Live."Type")
-                            GROUP BY Live."Type", Live."Name"
-                            HAVING sum(Live."Value") <> max(Agg."Value") OR max(Agg."Value") IS NULL;
+                                   SUM(LiveMax."Value")
+                            FROM (
+                                SELECT Live."Type",
+                                       Live."Name",
+                                       MAX(Live."Value") AS "Value"
+                                FROM livestatistics as Live
+                                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")
+                                        OR array_contains(array['minecraft:killed', 'minecraft:killed_by'], Live."Type")
+                                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()
                     )
         }

spa/src/AggregatesShowcase.js

@@ -2,59 +2,43 @@ import React from "react";
 import { useQuery } from "react-query";
 import axios from "axios";
 
-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 { SimpleGrid, Stat, StatLabel, StatNumber } from "@chakra-ui/react";
 import prettifyStatisticName from "./PrettifyStatisticName";
 import StackedBar from "./StackedBar";
 
 const AggregatesShowcase = () => {
-  const aggregates = useQuery(
-    `aggregates`,
-    async () => {
-      const { data } = await axios.get(`/api/aggregates`);
-      return data;
-    },
-    {
-      placeholderData: [],
-    }
-  );
+  const aggregates = useQuery(`aggregates`, async () => {
+    const { data } = await axios.get(`/api/aggregates`);
+    return data;
+  });
 
-  const killedAggregates = aggregates.data
-    .filter((x) => x.type === "minecraft:killed")
-    .sort((a, b) => b.value - a.value);
-  const killedTotal = killedAggregates.reduce((acc, val) => acc + val.value, 0);
+  const killedAggregates = aggregates.isSuccess
+    ? aggregates.data
+        .filter((x) => x.type === "minecraft:killed")
+        .sort((a, b) => b.value - a.value)
+    : [];
+  // const killedTotal = killedAggregates.reduce((acc, val) => acc + val.value, 0);
 
-  const killedByAggregates = aggregates.data
-    .filter((x) => x.type === "minecraft:killed_by")
-    .sort((a, b) => b.value - a.value);
-  const killedByTotal = killedByAggregates.reduce(
-    (acc, val) => acc + val.value,
-    0
-  );
+  const killedByAggregates = aggregates.isSuccess
+    ? aggregates.data
+        .filter((x) => x.type === "minecraft:killed_by")
+        .sort((a, b) => b.value - a.value)
+    : [];
+  // const killedByTotal = killedByAggregates.reduce(
+  //   (acc, val) => acc + val.value,
+  //   0
+  // );
 
-  const travelAggregates = aggregates.data
-    .filter((x) => x.type === "minecraft:custom" && x.name.endsWith("one_cm"))
-    .sort((a, b) => b.value - a.value);
-  const travelTotal = travelAggregates.reduce((acc, val) => acc + val.value, 0);
+  const travelAggregates = aggregates.isSuccess
+    ? aggregates.data
+        .filter(
+          (x) => x.type === "minecraft:custom" && x.name.endsWith("one_cm")
+        )
+        .sort((a, b) => b.value - a.value)
+    : [];
+  // const travelTotal = travelAggregates.reduce((acc, val) => acc + val.value, 0);
 
-  return aggregates.isFetched ? (
+  return aggregates.isSuccess ? (
     <>
       <StackedBar heading="Mobs Killed" aggregates={killedAggregates} />
 
@@ -73,13 +57,13 @@ const AggregatesShowcase = () => {
           .map((x, i) => {
             var value = x.value;
             if (x.name === "minecraft:play_one_minute") {
-              value = x.value / 20 / 60;
+              value = Math.floor(x.value / 20 / 60);
             }
 
             return (
               <Stat key={i}>
                 <StatLabel>{prettifyStatisticName(x.type, x.name)}</StatLabel>
-                <StatNumber>{`${x.value
+                <StatNumber>{`${value
                   .toString()
                   .replace(/\B(?=(\d{3})+(?!\d))/g, ",")}`}</StatNumber>
               </Stat>

spa/src/App.js

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

spa/src/Player.js

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

spa/src/StackedBar.js

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

spa/src/Statistic.js

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

spa/src/useHover.js

@@ -1,4 +1,4 @@
-import React, { useEffect, useRef, useState } from "react";
+import { 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];
 }