Add a miner that only supports Twitch moments for now

GetChannel propagates errors

Fix rewards being removed crashing the app

Author: chowder

cmd/live.go

@@ -1,7 +1,9 @@
 package cmd
 
 import (
+	"fmt"
 	"github.com/spf13/cobra"
+	"log"
 	"ttv-cli/internal/pkg/config"
 	"ttv-cli/internal/pkg/twitch/gql/operation/channelfollows"
 	"ttv-cli/internal/pkg/twitch/gql/query/users"
@@ -21,14 +23,20 @@ var liveCmd = &cobra.Command{
 		}
 
 		// Get all streamers from Twitch API
-		streamers := users.GetUsers(s)
+		streamers, err := users.GetUsers(s)
+		if err != nil {
+			log.Fatalf("Could not get channel information - %s\n", err)
+		}
 
 		// Filter between live and offline streamers
 		online := make([]users.User, 0)
 		offline := make([]users.User, 0)
 
-		for _, user := range streamers {
-			if user.Stream.CreatedAt != "" {
+		for i, user := range streamers {
+			if len(user.Id) == 0 {
+				fmt.Printf("Could not find channel information for '%s'\n", s[i])
+				continue
+			} else if user.Stream.CreatedAt != "" {
 				online = append(online, user)
 			} else {
 				offline = append(offline, user)

cmd/miner.go

@@ -0,0 +1,60 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"github.com/Adeithe/go-twitch"
+	"github.com/spf13/cobra"
+	"log"
+	"ttv-cli/internal/app/miner/moments"
+	"ttv-cli/internal/pkg/config"
+	"ttv-cli/internal/pkg/twitch/gql/query/users"
+)
+
+var minerCmd = &cobra.Command{
+	Use:   "miner",
+	Short: "Mines channel points, moments, and drops",
+	Args:  cobra.MinimumNArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		run(context.Background(), args)
+	},
+}
+
+func run(ctx context.Context, names []string) {
+	cfg := config.CreateOrRead()
+
+	p := twitch.PubSub()
+
+	p.OnShardConnect(func(shard int) {
+		fmt.Printf("Shard #%d connected!\n", shard)
+	})
+
+	streamerByIds := make(map[string]string, 0)
+	us, err := users.GetUsers(names)
+	if err != nil {
+		log.Fatalf("Could not fetch channel information for users - %s\n", err)
+	}
+
+	for i, u := range us {
+		if len(u.Id) == 0 {
+			log.Printf("Could not find user with name '%s'\n", names[i])
+			continue
+		}
+		streamerByIds[u.Id] = u.DisplayName
+	}
+
+	err = moments.MineMoments(p, streamerByIds, cfg.AuthToken)
+	if err != nil {
+		log.Fatalf("Could not subscribe to Moments - %s\n", err)
+	}
+
+	defer p.Close()
+
+	fmt.Printf("Started listening to %d topics on %d shards\n", p.GetNumTopics(), p.GetNumShards())
+
+	<-ctx.Done()
+}
+
+func init() {
+	rootCmd.AddCommand(minerCmd)
+}

internal/app/miner/moments/moments.go

@@ -0,0 +1,47 @@
+package moments
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/Adeithe/go-twitch/pubsub"
+	"log"
+	"strings"
+	"time"
+	moments "ttv-cli/internal/pkg/twitch/gql/operation/communitymomentcalloutclaim"
+	pubsub2 "ttv-cli/internal/pkg/twitch/pubsub"
+)
+
+const topic = "community-moments-channel-v1"
+
+func MineMoments(c *pubsub.Client, streamerByIds map[string]string, authToken string) error {
+	for id, s := range streamerByIds {
+		log.Printf("Listening to topic: '%s' for streamer: '%s' (%s)\n", topic, s, id)
+		if err := c.ListenWithAuth(authToken, topic, id); err != nil {
+			msg := fmt.Sprintf("Failed to listen to topic: '%s' for streamer: '%s' (%s) - %v", topic, s, id, err)
+			return errors.New(msg)
+		}
+		time.Sleep(time.Second)
+	}
+
+	handleUpdate := func(shard int, topic string, data []byte) {
+		fmt.Printf("Shard #%d > %s %s\n", shard, topic, strings.TrimSpace(string(data)))
+
+		var resp pubsub2.CommunityMomentsChannelResponse
+		if err := json.Unmarshal(data, &resp); err != nil {
+			log.Println(err)
+		}
+
+		if len(resp.MomentId) > 0 {
+			log.Printf("Attempting to redeem moment ID: '%s'\n", resp.MomentId)
+			err := moments.ClaimCommunityMoment(resp.MomentId, authToken)
+			if err != nil {
+				log.Println(err)
+			}
+		}
+	}
+
+	c.OnShardMessage(handleUpdate)
+
+	return nil
+}

internal/app/rewards/tui/model.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"github.com/charmbracelet/bubbles/list"
 	tea "github.com/charmbracelet/bubbletea"
+	"log"
 	"sort"
 	"ttv-cli/internal/pkg/twitch/gql/query/channel"
 	"ttv-cli/internal/pkg/twitch/pubsub"
@@ -19,14 +20,22 @@ type Model struct {
 }
 
 func NewModel(streamer string, authToken string) Model {
-	//listModel := list.New(make([]list.Item, 0), list.NewDefaultDelegate(), 0, 0)
+	c, err := channel.GetChannel(streamer)
+	if err != nil {
+		log.Fatalf("Failed to get channel information for '%s' - %s", streamer, err)
+	}
+	if len(c.Id) == 0 {
+		log.Fatalf("Could not find channel for '%s'\n", streamer)
+	}
+
 	m := Model{
-		twitchChannel:        channel.GetChannel(streamer),
+		twitchChannel:        c,
 		authToken:            authToken,
 		list:                 list.New(make([]list.Item, 0), list.NewDefaultDelegate(), 0, 0),
 		itemsById:            make(map[string]*item),
 		rewardsUpdateChannel: make(chan pubsub.CommunityPointsChannelResponse),
 	}
+
 	m.list.Title = fmt.Sprintf("%s's Rewards", m.twitchChannel.DisplayName)
 	return m
 }

internal/app/rewards/tui/update.go

@@ -27,7 +27,7 @@ func (m Model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		// Reward has been paused or disabled, remove it from the list
 		if msg.IsPaused || !msg.IsEnabled {
 			for index, listItem := range m.list.Items() {
-				if listItem.(item).RewardId == msg.Id {
+				if listItem.(*item).RewardId == msg.Id {
 					m.list.RemoveItem(index)
 				}
 			}

internal/pkg/twitch/gql/gql.go

@@ -3,6 +3,7 @@ package gql
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"io"
 	"io/ioutil"
 	"log"
@@ -50,6 +51,10 @@ func post(request any, authToken string) ([]byte, error) {
 		return nil, err
 	}
 
+	if httpResp.StatusCode != 200 {
+		return nil, errors.New(string(body)) // TODO: Narrow this to just the error
+	}
+
 	return body, nil
 }
 

internal/pkg/twitch/gql/operation/communitymomentcalloutclaim/communitymomentcalloutclaim.go

@@ -0,0 +1,57 @@
+package communitymomentcalloutclaim
+
+import (
+	"log"
+	"ttv-cli/internal/pkg/twitch/gql"
+)
+
+type input struct {
+	MomentID string `json:"momentID"`
+}
+
+type variables struct {
+	Input input `json:"input"`
+}
+
+type persistedQuery struct {
+	Version    int    `json:"version"`
+	Sha256Hash string `json:"sha256Hash"`
+}
+
+type extensions struct {
+	PersistedQuery persistedQuery `json:"persistedQuery"`
+}
+
+type request struct {
+	OperationName string     `json:"operationName"`
+	Variables     variables  `json:"variables"`
+	Extensions    extensions `json:"extensions"`
+}
+
+func makeRequest(momentId string) request {
+	return request{
+		OperationName: "CommunityMomentCallout_Claim",
+		Variables: variables{
+			Input: input{
+				MomentID: momentId,
+			},
+		},
+		Extensions: extensions{
+			PersistedQuery: persistedQuery{
+				Version:    1,
+				Sha256Hash: "e2d67415aead910f7f9ceb45a77b750a1e1d9622c936d832328a0689e054db62",
+			},
+		},
+	}
+}
+
+func ClaimCommunityMoment(momentId string, authToken string) error {
+	req := makeRequest(momentId)
+	resp, err := gql.PostWithAuth(req, authToken)
+	if err != nil {
+		return err
+	}
+
+	log.Println(string(resp))
+	return nil
+}

internal/pkg/twitch/gql/query/channel/channel.go

@@ -2,7 +2,6 @@ package channel
 
 import (
 	"encoding/json"
-	"log"
 	"ttv-cli/internal/pkg/twitch/gql"
 )
 
@@ -71,19 +70,20 @@ type CommunityPointsCustomRewardGlobalCooldownSetting struct {
 	IsEnabled             bool `json:"isEnabled"`
 }
 
-func GetChannel(name string) Channel {
+// GetChannel Note that this function will not throw if a channel was not found for the provided name
+func GetChannel(name string) (Channel, error) {
 	request := GetChannelRequest{Query: getChannelQuery}
 	request.Variables.Name = name
 
 	body, err := gql.Post(request)
 	if err != nil {
-		log.Fatalln(err)
+		return Channel{}, err
 	}
 
 	var response GetChannelResponse
 	if err := json.Unmarshal(body, &response); err != nil {
-		log.Fatalln(err)
+		return Channel{}, err
 	}
 
-	return response.Data.Channel
+	return response.Data.Channel, nil
 }

internal/pkg/twitch/gql/query/users/users.go

@@ -2,13 +2,13 @@ package users
 
 import (
 	"encoding/json"
-	"log"
 	"ttv-cli/internal/pkg/twitch/gql"
 )
 
 const getUsersQuery = `query Users($logins: [String!]) {
     users(logins: $logins) {
         displayName
+		id
 		login
         profileURL
         stream {
@@ -32,6 +32,7 @@ type request struct {
 
 type User struct {
 	DisplayName string `json:"displayName"`
+	Id          string `json:"id"`
 	Login       string `json:"login"`
 	ProfileURL  string `json:"profileURL"`
 	Stream      struct {
@@ -58,19 +59,18 @@ func makeRequest(logins []string) request {
 	}
 }
 
-func GetUsers(logins []string) []User {
-	// Create POST request body
+func GetUsers(logins []string) ([]User, error) {
 	request := makeRequest(logins)
 
 	gqlResp, err := gql.Post(request)
 	if err != nil {
-		log.Fatalln(err)
+		return nil, err
 	}
 
 	var response Response
 	if err := json.Unmarshal(gqlResp, &response); err != nil {
-		log.Fatalln(err)
+		return nil, err
 	}
 
-	return response.Data.Users
+	return response.Data.Users, nil
 }

internal/pkg/twitch/pubsub/communitymomentschannel.go

@@ -0,0 +1,6 @@
+package pubsub
+
+type CommunityMomentsChannelResponse struct {
+	Type     string `json:"type"`
+	MomentId string `json:"moment_id"`
+}