refactor out ws.inProgressMsgItem

cmd/server/ws.go

@@ -139,51 +139,85 @@ func (ws WS) inProgressMsg(ctx context.Context, ugs *UserGameServer, gameState G
 	msg["page"] = "B"
 	msg["event"] = "A"
 
-	items := []map[string]any{}
+	items, err := ws.inProgressMsgItems(ctx, ugs, gameState)
-	for k, v := range gameState.Players {
+	if err != nil {
-		if k == ugs.Session.ID {
+		return nil, err
-			continue
+	}
-		}
+	msg["items"] = items
 
-		name, err := ws.games.UserName(ctx, k)
+	return nil, io.EOF
+}
+
+type inProgressMsgItem struct {
+	Name  string                 `json:"name"`
+	Title string                 `json:"title"`
+	Tags  []inProgressMsgItemTag `json:"tags"`
+}
+
+type inProgressMsgItemTag struct {
+	K string `json:"k"`
+	V string `json:"v"`
+}
+
+func (ws WS) inProgressMsgItems(ctx context.Context, ugs *UserGameServer, gameState GameState) ([]inProgressMsgItem, error) {
+	items := []inProgressMsgItem{}
+	for k := range gameState.Players {
+		item, err := ws.inProgressMsgItem(ctx, ugs, gameState, k)
 		if err != nil {
 			return nil, err
 		}
-
+		if item == nil {
-		tags := []map[string]any{}
+			continue
-		if self := gameState.Players[ugs.Session.ID]; self.KillWords.Assignee == k {
-			for _, private := range v.KillWords.Assignment.Private {
-				tags = append(tags, map[string]any{
-					"k": private.Word,
-					"v": private.Points,
-				})
-			}
 		}
-		for _, public := range v.KillWords.Assignment.Public {
+		items = append(items, *item)
-			tags = append(tags, map[string]any{
-				"k": public.Word,
-				"v": public.Points,
-			})
-		}
-		if self := gameState.Players[ugs.Session.ID]; !slices.ContainsFunc(self.Kills, func(a Kill) bool {
-			return a.Victim == k
-		}) {
-			tags = append(tags, map[string]any{
-				"k": self.KillWords.Global.Word,
-				"v": self.KillWords.Global.Points,
-			})
-		}
-
-		items = append(items, map[string]any{
-			"name":  name,
-			"title": strconv.Itoa(v.Points()),
-			"tags":  tags,
-		})
 	}
-	slices.SortFunc(items, func(a, b map[string]any) int {
+	slices.SortFunc(items, func(a, b inProgressMsgItem) int {
-		an, _ := strconv.Atoi(fmt.Sprint(a["title"]))
+		an, _ := strconv.Atoi(a.Title)
-		bn, _ := strconv.Atoi(fmt.Sprint(b["title"]))
+		bn, _ := strconv.Atoi(b.Title)
 		return an - bn
 	})
-	return nil, io.EOF
+	return items, nil
+}
+
+func (ws WS) inProgressMsgItem(ctx context.Context, ugs *UserGameServer, gameState GameState, uid string) (*inProgressMsgItem, error) {
+	v := gameState.Players[uid]
+
+	if uid == ugs.Session.ID {
+		return nil, nil
+	}
+
+	name, err := ws.games.UserName(ctx, uid)
+	if err != nil {
+		return nil, err
+	}
+
+	tags := []inProgressMsgItemTag{}
+	if self := gameState.Players[ugs.Session.ID]; self.KillWords.Assignee == uid {
+		for _, private := range v.KillWords.Assignment.Private {
+			tags = append(tags, inProgressMsgItemTag{
+				K: private.Word,
+				V: strconv.Itoa(private.Points),
+			})
+		}
+	}
+	for _, public := range v.KillWords.Assignment.Public {
+		tags = append(tags, inProgressMsgItemTag{
+			K: public.Word,
+			V: strconv.Itoa(public.Points),
+		})
+	}
+	if self := gameState.Players[ugs.Session.ID]; !slices.ContainsFunc(self.Kills, func(a Kill) bool {
+		return a.Victim == uid
+	}) {
+		tags = append(tags, inProgressMsgItemTag{
+			K: self.KillWords.Global.Word,
+			V: strconv.Itoa(self.KillWords.Global.Points),
+		})
+	}
+
+	return &inProgressMsgItem{
+		Name:  name,
+		Title: strconv.Itoa(v.Points()),
+		Tags:  tags,
+	}, nil
 }