Generating custom live events

Suppose you want to generate a new event every time a goal is scored on some soccer game and send that to all clients subscribed to a given game according to a tag t.

We'll assume you'll be polling some HTTP API that gives you the game's current score, and that in your main function you'll start the function that does the polling:

func main () {
	// other stuff here
	relay := khatru.NewRelay()

	go startPollingGame(relay)
	// other stuff here
}

type GameStatus struct {
	TeamA int `json:"team_a"`
	TeamB int `json:"team_b"`
}

func startPollingGame(relay *khatru.Relay) {
	current := GameStatus{0, 0}

	for {
		newStatus, err := fetchGameStatus()
		if err != nil {
				continue
		}

		if newStatus.TeamA > current.TeamA {
				// team A has scored a goal, here we generate an event
				evt := nostr.Event{
					CreatedAt: nostr.Now(),
					Kind: 1,
					Content: "team A has scored!",
					Tags: nostr.Tags{{"t", "this-game"}}
				}
				evt.Sign(global.RelayPrivateKey)
				// calling BroadcastEvent will send the event to everybody who has been listening for tag "t=[this-game]"
				// there is no need to do any code to keep track of these clients or who is listening to what, khatru
				// does that already in the background automatically
				relay.BroadcastEvent(evt)

				// just calling BroadcastEvent won't cause this event to be be stored,
				// if for any reason you want to store these events you must call the store functions manually
				for _, store := range relay.StoreEvent {
					store(context.TODO(), evt)
				}
		}
		if newStatus.TeamB > current.TeamB {
				// same here, if team B has scored a goal
				// ...
		}
	}
}

func fetchGameStatus() (GameStatus, error) {
	// implementation of calling some external API goes here
}