fix: try to make sure order when mixed changes

cutt/analysis.py

@@ -349,24 +349,26 @@ def last_submissions(
 
 
 def mvp(
-    request: Annotated[TeamScopedRequest, Security(verify_team_scope)],
+    request: Annotated[TeamScopedRequest, Security(verify_team_scope)], mixed=False
 ):
-    ranks = dict()
     if request.team_id == 42:
+        ranks = {}
         random.seed(42)
         players = [request.user] + demo_players
         for p in players:
             random.shuffle(players)
             for i, p in enumerate(players):
-                ranks[p.display_name] = ranks.get(p.display_name, []) + [i + 1]
+                ranks[p.id] = ranks.get(p.id, []) + [i + 1]
         return [
-            {
+            [
-                "name": p,
+                {
-                "rank": f"{np.mean(v):.02f}",
+                    "p_id": p_id,
-                "std": f"{np.std(v):.02f}",
+                    "rank": f"{np.mean(v):.02f}",
-                "n": len(v),
+                    "std": f"{np.std(v):.02f}",
-            }
+                    "n": len(v),
-            for p, v in ranks.items()
+                }
+                for i, (p_id, v) in enumerate(ranks.items())
+            ]
         ]
 
     with Session(engine) as session:
@@ -378,7 +380,7 @@ def mvp(
         ).all()
         if not players:
             raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
-        player_map = {p.id: p.display_name for p in players}
+        player_map = {p.id: p for p in players}
         subquery = (
             select(R.user, func.max(R.time).label("latest"))
             .where(R.team == request.team_id)
@@ -388,25 +390,45 @@ def mvp(
         statement2 = select(R).join(
             subquery, (R.user == subquery.c.user) & (R.time == subquery.c.latest)
         )
-        for r in session.exec(statement2):
+        if mixed:
-            for i, p_id in enumerate(r.mvps):
+            all_ranks = []
-                if p_id not in player_map:
+            for gender in ["fmp", "mmp"]:
-                    continue
+                ranks = {}
-                p = player_map[p_id]
+                for r in session.exec(statement2):
-                ranks[p] = ranks.get(p, []) + [i + 1]
+                    mvps = [
+                        p_id
+                        for p_id in r.mvps
+                        if p_id in player_map and player_map[p_id].gender == gender
+                    ]
+                    for i, p_id in enumerate(mvps):
+                        p = player_map[p_id]
+                        ranks[p_id] = ranks.get(p_id, []) + [i + 1]
+                all_ranks.append(ranks)
+        else:
+            ranks = {}
+            for r in session.exec(statement2):
+                for i, p_id in enumerate(r.mvps):
+                    if p_id not in player_map:
+                        continue
+                    p = player_map[p_id]
+                    ranks[p_id] = ranks.get(p_id, []) + [i + 1]
+            all_ranks = [ranks]
 
-    if not ranks:
+    if not all_ranks:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND, detail="no entries found"
         )
     return [
-        {
+        [
-            "name": p,
+            {
-            "rank": f"{np.mean(v):.02f}",
+                "p_id": p_id,
-            "std": f"{np.std(v):.02f}",
+                "rank": f"{np.mean(v):.02f}",
-            "n": len(v),
+                "std": f"{np.std(v):.02f}",
-        }
+                "n": len(v),
-        for p, v in ranks.items()
+            }
+            for p_id, v in ranks.items()
+        ]
+        for ranks in all_ranks
     ]
 
 

cutt/demo.py

@@ -16,7 +16,7 @@ names = [
 demo_players = [
     Player.model_validate(
         {
-            "id": i,
+            "id": i + 4200,
             "display_name": name,
             "username": name.lower().replace(" ", "").replace(".", ""),
             "gender": gender,

src/MVPChart.tsx

@@ -6,12 +6,13 @@ import { useSession } from "./Session";
 import { useNavigate } from "react-router";
 
 const MVPChart = () => {
-  let initialData = {} as PlayerRanking[];
+  let initialData = {} as PlayerRanking[][];
   const [data, setData] = useState(initialData);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState("");
   const [showStd, setShowStd] = useState(false);
   const { user, teams } = useSession();
+  const [mixed, setMixed] = useState(false);
   const navigate = useNavigate();
   useEffect(() => {
     user?.scopes.includes(`team:${teams?.activeTeam}`) ||
@@ -19,21 +20,30 @@ const MVPChart = () => {
       navigate("/", { replace: true });
   }, [user]);
 
+  useEffect(() => {
+    if (teams) {
+      const activeTeam = teams.teams.find(
+        (team) => team.id == teams.activeTeam
+      );
+      activeTeam && setMixed(activeTeam.mixed);
+    }
+  }, [teams]);
+
   async function loadData() {
     setLoading(true);
     if (teams) {
-      await apiAuth(`analysis/mvp/${teams?.activeTeam}`, null)
+      await apiAuth(`analysis/mvp/${teams?.activeTeam}?mixed=${mixed}`, null)
         .then((data) => {
           if (data.detail) {
             setError(data.detail);
             return initialData;
           } else {
             setError("");
-            return data as Promise<PlayerRanking[]>;
+            return data as Promise<PlayerRanking[][]>;
           }
         })
         .then((data) => {
-          setData(data.sort((a, b) => a.rank - b.rank));
+          setData(data.map((_data) => _data.sort((a, b) => a.rank - b.rank)));
         })
         .catch(() => setError("no access"));
       setLoading(false);
@@ -46,7 +56,8 @@ const MVPChart = () => {
 
   if (loading) return <span className="loader" />;
   else if (error) return <span>{error}</span>;
-  else return <RaceChart std={showStd} players={data} />;
+  else
+    return data.map((_data) => <RaceChart std={showStd} playerRanks={_data} />);
 };
 
 export default MVPChart;

src/RaceChart.tsx

@@ -1,8 +1,9 @@
 import { FC, useEffect, useState } from "react";
 import { PlayerRanking } from "./types";
+import { useSession } from "./Session";
 
 interface RaceChartProps {
-  players: PlayerRanking[];
+  playerRanks: PlayerRanking[];
   std: boolean;
 }
 
@@ -13,15 +14,14 @@ const determineNiceWidth = (width: number) => {
   else return width * 0.96;
 };
 
-const RaceChart: FC<RaceChartProps> = ({ players, std }) => {
+const RaceChart: FC<RaceChartProps> = ({ playerRanks, std }) => {
   const [width, setWidth] = useState(determineNiceWidth(window.innerWidth));
-  //const [height, setHeight] = useState(window.innerHeight);
+  const height = (playerRanks.length + 1) * 40;
-  const height = (players.length + 1) * 40;
+  const { players } = useSession();
 
   useEffect(() => {
     const handleResize = () => {
       setWidth(determineNiceWidth(window.innerWidth));
-      //setHeight(window.innerHeight);
     };
     window.addEventListener("resize", handleResize);
     return () => {
@@ -30,18 +30,18 @@ const RaceChart: FC<RaceChartProps> = ({ players, std }) => {
   }, []);
   const padding = 24;
   const gap = 8;
-  const maxValue = Math.max(...players.map((player) => player.rank)) + 1;
+  const maxValue = Math.max(...playerRanks.map((player) => player.rank)) + 1;
-  const barHeight = (height - 2 * padding) / players.length;
+  const barHeight = (height - 2 * padding) / playerRanks.length;
   const fontSize = Math.min(barHeight - 1.5 * gap, width / 22);
 
   return (
     <svg width={width} height={height} id="RaceChartSVG">
-      {players.map((player, index) => (
+      {playerRanks.map((playerRank, index) => (
         <rect
           key={String(index)}
           x={4}
           y={index * barHeight + padding}
-          width={(1 - player.rank / maxValue) * width}
+          width={(1 - playerRank.rank / maxValue) * width}
           height={barHeight - gap} // subtract 2 for some spacing between bars
           fill="#36c"
           stroke="aliceblue"
@@ -50,49 +50,53 @@ const RaceChart: FC<RaceChartProps> = ({ players, std }) => {
         />
       ))}
 
-      {players.map((player, index) => (
+      {playerRanks.map((playerRank, index) => {
-        <g key={"group" + index}>
+        const player = players!.find((p) => p.id === playerRank.p_id);
-          <text
+        return (
-            key={index + "_name"}
+          <g key={"group" + index}>
-            x={8}
+            <text
-            y={index * barHeight + barHeight / 2 + padding + gap / 2}
+              key={index + "_name"}
-            width={(1 - player.rank / maxValue) * width}
+              x={8}
-            height={barHeight - 8} // subtract 2 for some spacing between bars
+              y={index * barHeight + barHeight / 2 + padding + gap / 2}
-            fontSize={fontSize}
+              width={(1 - playerRank.rank / maxValue) * width}
-            fill="aliceblue"
+              height={barHeight - 8} // subtract 2 for some spacing between bars
-            stroke="#36c"
+              fontSize={fontSize}
-            strokeWidth={4}
+              fill="aliceblue"
-            fontWeight={"bold"}
+              stroke="#36c"
-            paintOrder={"stroke fill"}
+              strokeWidth={4}
-            fontFamily="monospace"
+              fontWeight={"bold"}
-            style={{ whiteSpace: "pre" }}
+              paintOrder={"stroke fill"}
-          >
+              fontFamily="monospace"
-            {`${String(index + 1).padStart(2)}. ${player.name}`}
+              style={{ whiteSpace: "pre" }}
-          </text>
+            >
-          <text
+              {`${String(index + 1).padStart(2)}. ${player?.display_name}`}
-            key={index + "_value"}
+            </text>
-            x={
+            <text
-              8 +
+              key={index + "_value"}
-              (4 + Math.max(...players.map((p, _) => p.name.length))) *
+              x={
-                fontSize *
+                8 +
-                0.66
+                (4 +
-            }
+                  Math.max(...players!.map((p, _) => p.display_name.length))) *
-            y={index * barHeight + barHeight / 2 + padding + gap / 2}
+                  fontSize *
-            width={(1 - player.rank / maxValue) * width}
+                  0.66
-            height={barHeight - 8} // subtract 2 for some spacing between bars
+              }
-            fontSize={0.8 * fontSize}
+              y={index * barHeight + barHeight / 2 + padding + gap / 2}
-            fill="aliceblue"
+              width={(1 - playerRank.rank / maxValue) * width}
-            stroke="#36c"
+              height={barHeight - 8} // subtract 2 for some spacing between bars
-            fontWeight={"bold"}
+              fontSize={0.8 * fontSize}
-            fontFamily="monospace"
+              fill="aliceblue"
-            strokeWidth={4}
+              stroke="#36c"
-            paintOrder={"stroke fill"}
+              fontWeight={"bold"}
-            style={{ whiteSpace: "pre" }}
+              fontFamily="monospace"
-          >
+              strokeWidth={4}
-            {`${String(player.rank).padStart(5)} ± ${player.std}   N = ${player.n}`}
+              paintOrder={"stroke fill"}
-          </text>
+              style={{ whiteSpace: "pre" }}
-        </g>
+            >
-      ))}
+              {`${String(playerRank.rank).padStart(5)} ± ${playerRank.std}   N = ${playerRank.n}`}
+            </text>
+          </g>
+        );
+      })}
     </svg>
   );
 };

src/Rankings.tsx

@@ -345,6 +345,11 @@ function MVPDnD({ user, teams, players }: PlayerInfoProps) {
     handleGet();
   }, [players]);
 
+  useEffect(() => {
+    handleGet();
+    // setMixedList(rankedPlayers);
+  }, [mixed]);
+
   const [dialog, setDialog] = useState("dialog");
   const dialogRef = useRef<HTMLDialogElement>(null);
 
@@ -357,6 +362,15 @@ function MVPDnD({ user, teams, players }: PlayerInfoProps) {
     response ? setDialog(response) : setDialog("try sending again");
   }
 
+  const setMixedList = (newList: User[]) =>
+    mixed
+      ? setRankedPlayers(
+          newList.sort((a, b) =>
+            a.gender && b.gender ? a.gender.localeCompare(b.gender) : -1
+          )
+        )
+      : setRankedPlayers(newList);
+
   async function handleGet() {
     setLoading(true);
     const data = await apiAuth(`mvps/${teams.activeTeam}`, null, "GET");
@@ -366,7 +380,7 @@ function MVPDnD({ user, teams, players }: PlayerInfoProps) {
       setRankedPlayers([]);
     } else {
       const mvps = data as MVPRanking;
-      setRankedPlayers(filterSort(players, mvps.mvps));
+      setMixedList(filterSort(players, mvps.mvps));
       setAvailablePlayers(
         players.filter((user) => !mvps.mvps.includes(user.id))
       );
@@ -412,17 +426,7 @@ function MVPDnD({ user, teams, players }: PlayerInfoProps) {
             )}
             <PlayerList
               list={rankedPlayers}
-              setList={(newList) =>
+              setList={setMixedList}
-                mixed
-                  ? setRankedPlayers(
-                      newList.sort((a, b) =>
-                        a.gender && b.gender
-                          ? a.gender.localeCompare(b.gender)
-                          : -1
-                      )
-                    )
-                  : setRankedPlayers(newList)
-              }
               group={{
                 name: "mvp-shared",
               }}

src/types.ts

@@ -13,7 +13,7 @@ export default interface NetworkData {
 }
 
 export interface PlayerRanking {
-  name: string;
+  p_id: number;
   rank: number;
   std: number;
   n: number;