refactor to share

cmd/server/games.go

@@ -168,6 +168,63 @@ const (
 	AssignmentRotation
 )
 
+type Event interface{ event() }
+
+func (EventPlayerJoin) event()         {}
+func (EventPlayerLeave) event()        {}
+func (EventGameComplete) event()       {}
+func (EventAssignmentRotation) event() {}
+
+func (games Games) GameEvents(ctx context.Context, id string, since time.Time) ([]Event, error) {
+	var results []Event
+	err := games.db.Query(ctx, func(rows *sql.Rows) error {
+		var timestamp time.Time
+		var b []byte
+		if err := rows.Scan(&timestamp, &b); err != nil {
+			return err
+		}
+		event, err := parseEvent(b)
+		results = append(results, event)
+		return err
+	}, `
+		SELECT
+			timestamp,
+			payload
+		FROM events
+		WHERE game_uuid=? and timestamp>?
+		ORDER BY timestamp ASC
+	`, id, since)
+	return results, err
+}
+
+func parseEvent(b []byte) (Event, error) {
+	var peek struct {
+		Type EventType
+	}
+	if err := json.Unmarshal(b, &peek); err != nil {
+		return nil, err
+	}
+	switch peek.Type {
+	case PlayerJoin:
+		var playerJoin EventPlayerJoin
+		err := json.Unmarshal(b, &playerJoin)
+		return playerJoin, err
+	case PlayerLeave:
+		var playerLeave EventPlayerLeave
+		err := json.Unmarshal(b, &playerLeave)
+		return playerLeave, err
+	case GameComplete:
+		var gameComplete EventGameComplete
+		err := json.Unmarshal(b, &gameComplete)
+		return gameComplete, err
+	case AssignmentRotation:
+		var assignmentRotation EventAssignmentRotation
+		err := json.Unmarshal(b, &assignmentRotation)
+		return assignmentRotation, err
+	}
+	return nil, fmt.Errorf("unknown event type %d: %s", peek.Type, b)
+}
+
 func (games Games) GameState(ctx context.Context, id string) (GameState, error) {
 	result := GameState{Players: map[string]PlayerState{}}
 
@@ -178,41 +235,26 @@ func (games Games) GameState(ctx context.Context, id string) (GameState, error)
 			return err
 		}
 
-		var peek struct {
+		event, err := parseEvent(payload)
-			Type EventType
+		if err != nil {
-		}
-		if err := json.Unmarshal(payload, &peek); err != nil {
 			return err
 		}
 
-		switch peek.Type {
+		switch event.(type) {
-		case PlayerJoin:
+		case EventPlayerJoin:
-			var playerJoin EventPlayerJoin
+			playerJoin := event.(EventPlayerJoin)
-			if err := json.Unmarshal(payload, &playerJoin); err != nil {
-				return err
-			}
 			result.Players[playerJoin.ID] = PlayerState{}
 			return nil
-		case PlayerLeave:
+		case EventPlayerLeave:
-			var playerLeave EventPlayerLeave
+			playerLeave := event.(EventPlayerLeave)
-			if err := json.Unmarshal(payload, &playerLeave); err != nil {
-				return err
-			}
 			delete(result.Players, playerLeave.ID)
 			return nil
-		case GameComplete:
+		case EventGameComplete:
-			var gameComplete EventGameComplete
-			if err := json.Unmarshal(payload, &gameComplete); err != nil {
-				return err
-			}
 			result.Completed = timestamp
 			return nil
-		case AssignmentRotation:
+		case EventAssignmentRotation:
 			result.Started = true
-			var assignmentRotation EventAssignmentRotation
+			assignmentRotation := event.(EventAssignmentRotation)
-			if err := json.Unmarshal(payload, &assignmentRotation); err != nil {
-				return err
-			}
 
 			if killer, ok := result.Players[assignmentRotation.Killer]; !ok {
 			} else if _, ok := result.Players[assignmentRotation.Victim]; !ok {
@@ -237,7 +279,7 @@ func (games Games) GameState(ctx context.Context, id string) (GameState, error)
 			}
 			return nil
 		default:
-			return fmt.Errorf("unknown event type %d: %s", peek.Type, payload)
+			return fmt.Errorf("unknown event type %T: %s", event, payload)
 		}
 
 		return nil