Rewards app now shows remaining channel points

Config now fetches auth token context

Fix models for CommunityPointsUser and CommunityMomentsChannel

Fix Moments miner

Author: chowder

cmd/rewards.go

@@ -1,6 +1,7 @@
 package cmd
 
 import (
+	"github.com/Adeithe/go-twitch"
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/spf13/cobra"
 	"log"
@@ -21,7 +22,11 @@ var rewardsCmd = &cobra.Command{
 		}
 
 		s := strings.ToLower(args[0])
-		m := tui.NewModel(s, c.AuthToken)
+
+		pc := twitch.PubSub()
+		defer pc.Close()
+
+		m := tui.NewModel(pc, c, s)
 
 		p := tea.NewProgram(m, tea.WithAltScreen())
 

internal/app/miner/moments/moments.go

@@ -33,24 +33,12 @@ func MineMoments(c *pubsub.Client, streamerByIds map[string]string, authToken st
 			return
 		}
 
-		var message communitymomentschannel.Message
-		if err := json.Unmarshal([]byte(resp.Data.Message), &message); err != nil {
-			log.Printf("could not unmarshal response message: %s, error: %s\n", resp.Data.Message, err)
-			return
-		}
-
-		if message.Type == "active" {
-			log.Printf("Active moment received, data: %s\n", message.Data)
-			var data communitymomentschannel.ActiveMomentData
-			if err := json.Unmarshal(message.Data, &data); err != nil {
-				log.Printf("could not unmarshal response message data: %s, error: %s\n", message.Data, err)
-				return
-			}
-
-			log.Printf("Attempting to redeem moment ID: '%s'\n", data.MomentId)
-			err := communitymomentcalloutclaim.Claim(data.MomentId, authToken)
+		momentId := resp.Data.MomentId
+		if len(momentId) > 0 {
+			log.Printf("Attempting to redeem moment ID: '%s'\n", momentId)
+			err := communitymomentcalloutclaim.Claim(momentId, authToken)
 			if err != nil {
-				log.Printf("could not claim moment: %s, error: %s\n", data.MomentId, err)
+				log.Printf("could not claim moment: %s, error: %s\n", momentId, err)
 			}
 		}
 	}

internal/app/rewards/tui/model.go

@@ -1,25 +1,30 @@
 package tui
 
 import (
-	"context"
 	"fmt"
+	"github.com/Adeithe/go-twitch/pubsub"
 	"github.com/charmbracelet/bubbles/list"
 	tea "github.com/charmbracelet/bubbletea"
 	"log"
 	"sort"
+	"ttv-cli/internal/pkg/config"
+	"ttv-cli/internal/pkg/twitch/gql/operation/channelpointscontext"
 	"ttv-cli/internal/pkg/twitch/gql/query/channel"
 	"ttv-cli/internal/pkg/twitch/pubsub/communitypointschannel"
+	"ttv-cli/internal/pkg/twitch/pubsub/communitypointsuser"
 )
 
 type Model struct {
 	twitchChannel        channel.Channel
-	authToken            string
+	config               config.Config
 	list                 list.Model
 	itemsById            map[string]*item
 	rewardsUpdateChannel chan communitypointschannel.Response
+	pointsUpdateChannel  chan communitypointsuser.Response
+	pubsubClient         *pubsub.Client
 }
 
-func NewModel(streamer string, authToken string) Model {
+func NewModel(pubsubClient *pubsub.Client, config config.Config, streamer string) Model {
 	c, err := channel.GetChannel(streamer)
 	if err != nil {
 		log.Fatalf("Failed to get channel information for '%s' - %s", streamer, err)
@@ -30,20 +35,31 @@ func NewModel(streamer string, authToken string) Model {
 
 	m := Model{
 		twitchChannel:        c,
-		authToken:            authToken,
+		config:               config,
 		list:                 list.New(make([]list.Item, 0), list.NewDefaultDelegate(), 0, 0),
 		itemsById:            make(map[string]*item),
 		rewardsUpdateChannel: make(chan communitypointschannel.Response),
+		pointsUpdateChannel:  make(chan communitypointsuser.Response),
 	}
 
-	m.list.Title = fmt.Sprintf("%s's Rewards", m.twitchChannel.DisplayName)
+	channelPointsContext, err := channelpointscontext.Get(c.Name, config.AuthToken)
+	if err != nil {
+		log.Fatalf("Could not fetch channel points context: %s", err)
+	}
+
+	balance := channelPointsContext.Data.Community.Channel.Self.CommunityPoints.Balance
+
+	m.list.Title = fmt.Sprintf("%s's Rewards (%d points)", m.twitchChannel.DisplayName, balance)
+
+	m.pubsubClient = pubsubClient
+
 	return m
 }
 
 func (m Model) Init() tea.Cmd {
-	ctx := context.Background() // TODO: Close this context on app exit
-	go m.subscribeToRewards(ctx)
-	return tea.Batch(m.getInitialRewards, m.tick())
+	go m.subscribeToRewards()
+	go m.subscribeToPoints()
+	return tea.Batch(m.getInitialRewards, m.processPointsUpdates, m.tick())
 }
 
 func (m Model) View() string {

internal/app/rewards/tui/update.go

@@ -1,27 +1,27 @@
 package tui
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
-	"github.com/Adeithe/go-twitch"
 	"github.com/charmbracelet/bubbles/list"
 	tea "github.com/charmbracelet/bubbletea"
 	"log"
 	"time"
 	"ttv-cli/internal/pkg/twitch/gql/operation/redeemcustomreward"
 	"ttv-cli/internal/pkg/twitch/pubsub/communitypointschannel"
+	"ttv-cli/internal/pkg/twitch/pubsub/communitypointsuser"
 )
 
 type initialRewards []list.Item
 type updatedReward communitypointschannel.UpdatedReward
 type tick int
+type newBalance int
 
 func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
 	case initialRewards:
 		cmd := m.list.SetItems(msg)
-		return m, tea.Batch(cmd, m.processUpdates, m.tick())
+		return m, tea.Batch(cmd, m.processRewardUpdates, m.tick())
 
 	case updatedReward:
 		// Reward has been paused or disabled, remove it from the list
@@ -35,7 +35,11 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		} else if item, ok := m.itemsById[msg.Id]; ok {
 			item.CooldownExpiresAt = msg.CooldownExpiresAt
 		}
-		return m, m.processUpdates
+		return m, m.processRewardUpdates
+
+	case newBalance:
+		m.list.Title = fmt.Sprintf("%s's Rewards (%d points)", m.twitchChannel.DisplayName, msg)
+		return m, m.processPointsUpdates
 
 	case tick:
 		cmd := m.list.SetItems(m.list.Items()) // Force re-render
@@ -72,29 +76,52 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	return m, cmd
 }
 
-func (m Model) subscribeToRewards(ctx context.Context) {
-	p := twitch.PubSub()
-	err := p.Listen("community-points-channel-v1", m.twitchChannel.Id)
+func (m Model) subscribeToRewards() {
+	err := m.pubsubClient.Listen("community-points-channel-v1", m.twitchChannel.Id)
 	if err != nil {
-		log.Fatalln(err)
+		log.Fatalf("Could not subscribe to community-points-channel-v1: %s\n", err)
 	}
 
-	defer p.Close()
-
-	handleUpdate := func(_ int, _ string, data []byte) {
-		response := communitypointschannel.Response{}
-		if err := json.Unmarshal(data, &response); err != nil {
-			log.Fatalln(err)
+	subscribedTopic := "community-points-channel-v1." + m.twitchChannel.Id
+	handleUpdate := func(_ int, topic string, data []byte) {
+		if topic == subscribedTopic {
+			var response communitypointschannel.Response
+			if err := json.Unmarshal(data, &response); err != nil {
+				log.Fatalln(err)
+			}
+			m.rewardsUpdateChannel <- response
 		}
-		m.rewardsUpdateChannel <- response
 	}
 
-	p.OnShardMessage(handleUpdate)
+	m.pubsubClient.OnShardMessage(handleUpdate)
+}
+
+func (m Model) subscribeToPoints() {
+	userId := m.config.TokenDetails.UserId
 
-	<-ctx.Done()
+	err := m.pubsubClient.ListenWithAuth(m.config.AuthToken, "community-points-user-v1", userId)
+	if err != nil {
+		log.Fatalf("Could not subscribe to community-points-user-v1.%s: %s\n", m.twitchChannel.Id, err)
+	}
+
+	subscribedTopic := "community-points-user-v1." + userId
+	handleUpdate := func(_ int, topic string, data []byte) {
+		if topic == subscribedTopic {
+			var response communitypointsuser.Response
+			if err := json.Unmarshal(data, &response); err != nil {
+				log.Fatalf("Failed to unmarshal response: %s, error: %s\n", data, err)
+			}
+
+			if response.Type == "points-earned" || response.Type == "points-spent" {
+				m.pointsUpdateChannel <- response
+			}
+		}
+	}
+
+	m.pubsubClient.OnShardMessage(handleUpdate)
 }
 
-func (m Model) processUpdates() tea.Msg {
+func (m Model) processRewardUpdates() tea.Msg {
 	for update := range m.rewardsUpdateChannel {
 		if update.Type == "custom-reward-updated" {
 			return updatedReward(update.Data.UpdatedReward)
@@ -103,6 +130,25 @@ func (m Model) processUpdates() tea.Msg {
 	return nil // Unreachable
 }
 
+func (m Model) processPointsUpdates() tea.Msg {
+	for update := range m.pointsUpdateChannel {
+		if update.Type == "points-spent" {
+			var data communitypointsuser.PointsSpentData
+			if err := json.Unmarshal(update.Data, &data); err != nil {
+				log.Fatalf("Could not process point update: %s, error: %s\n", update, err)
+			}
+			return newBalance(data.Balance.Balance)
+		} else if update.Type == "points-earned" {
+			var data communitypointsuser.PointsEarnedData
+			if err := json.Unmarshal(update.Data, &data); err != nil {
+				log.Fatalf("Could not process point update: %s, error: %s\n", update, err)
+			}
+			return newBalance(data.Balance.Balance)
+		}
+	}
+	return nil
+}
+
 func (m Model) tick() tea.Cmd {
 	return tea.Tick(time.Second, func(_ time.Time) tea.Msg {
 		return tick(0)
@@ -123,7 +169,7 @@ func (m Model) redeemReward(i *item) error {
 		input.TextInput = ":)" // FIXME
 	}
 
-	_, err := redeemcustomreward.Redeem(input, m.authToken)
+	_, err := redeemcustomreward.Redeem(input, m.config.AuthToken)
 	if err != nil {
 		return fmt.Errorf("could not redeem reward: %w", err)
 	}

internal/pkg/config/config.go

@@ -3,14 +3,23 @@ package config
 import (
 	"encoding/json"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"path"
 	"ttv-cli/internal/pkg/twitch/login"
 )
 
+type TokenDetails struct {
+	ClientId  string
+	Login     string
+	Scopes    []string
+	UserId    string
+	ExpiresIn int
+}
+
+// Config only stores the auth token - token details retrieved when the token is validated
 type Config struct {
-	AuthToken string `json:"auth_token"`
+	AuthToken    string `json:"auth_token"`
+	TokenDetails TokenDetails
 }
 
 func GetConfigFilePath() string {
@@ -21,8 +30,7 @@ func GetConfigFilePath() string {
 func createDefaultConfig() (Config, error) {
 	emptyConfig := Config{AuthToken: ""}
 
-	err := emptyConfig.validateAuthToken()
-	if err != nil {
+	if err := emptyConfig.validateAuthToken(); err != nil {
 		return Config{}, fmt.Errorf("createDefaultConfig: error when validating Twitch auth token: %w", err)
 	}
 
@@ -31,7 +39,7 @@ func createDefaultConfig() (Config, error) {
 
 func CreateOrRead() (Config, error) {
 	configFilePath := GetConfigFilePath()
-	contents, err := ioutil.ReadFile(configFilePath)
+	contents, err := os.ReadFile(configFilePath)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return createDefaultConfig()
@@ -44,31 +52,55 @@ func CreateOrRead() (Config, error) {
 		return Config{}, fmt.Errorf("CreateOrRead: Error when unmarshalling config file: %w", err)
 	}
 
-	if err = config.validateAuthToken(); err != nil {
+	if err := config.validateAuthToken(); err != nil {
 		return Config{}, fmt.Errorf("CreateOrRead: Error when validating Twitch auth token: %w", err)
 	}
 
 	return config, nil
 }
 
-func (c Config) validateAuthToken() error {
-	if len(c.AuthToken) == 0 || login.Validate(c.AuthToken) != nil {
-		fmt.Println("Auth token not found or expired, generating a new one for you...")
+func (c *Config) refreshAuthToken() error {
+	authToken, err := login.GetAccessToken("", "")
+	if err != nil {
+		return fmt.Errorf("validateAuthToken: Error getting Twitch access token: %w", err)
+	}
+
+	c.AuthToken = authToken
+	if err := c.Save(); err != nil {
+		return fmt.Errorf("validateAuthToken: Error saving config: %w", err)
+	}
 
-		authToken, err := login.GetAccessToken("", "")
-		if err != nil {
-			return fmt.Errorf("validateAuthToken: Error getting Twitch access token: %w", err)
+	return nil
+}
+
+func (c *Config) validateAuthToken() error {
+	if len(c.AuthToken) == 0 {
+		fmt.Println("Auth token not found, generating a new one for you...")
+		if err := c.refreshAuthToken(); err != nil {
+			return fmt.Errorf("could not refresh auth token: %w", err)
 		}
+	}
 
-		c.AuthToken = authToken
-		if err := c.Save(); err != nil {
-			return fmt.Errorf("validateAuthToken: Error saving config: %w", err)
+	resp, err := login.Validate(c.AuthToken)
+	if err != nil {
+		fmt.Println("Auth token is stale or invalid, generating a new one for you...")
+		if err := c.refreshAuthToken(); err != nil {
+			return fmt.Errorf("could not refresh auth token: %w", err)
 		}
 	}
+
+	c.TokenDetails = TokenDetails{
+		ClientId:  resp.ClientId,
+		Login:     resp.Login,
+		Scopes:    resp.Scopes,
+		UserId:    resp.UserId,
+		ExpiresIn: resp.ExpiresIn,
+	}
+
 	return nil
 }
 
-func (c Config) Save() error {
+func (c *Config) Save() error {
 	configFilePath := GetConfigFilePath()
 	contents, err := json.MarshalIndent(c, "", "  ")
 	if err != nil {
@@ -80,7 +112,7 @@ func (c Config) Save() error {
 		return fmt.Errorf("could not create config directory: %w", err)
 	}
 
-	if err := ioutil.WriteFile(configFilePath, contents, 0644); err != nil {
+	if err := os.WriteFile(configFilePath, contents, 0644); err != nil {
 		return fmt.Errorf("could not write to config file: %w", err)
 	}