150 lines
3.3 KiB
Go
150 lines
3.3 KiB
Go
package twitchapi
|
|
|
|
import (
|
|
"fmt"
|
|
"time"
|
|
|
|
helix "github.com/nicklaw5/helix"
|
|
)
|
|
|
|
type Client struct {
|
|
api *helix.Client
|
|
}
|
|
|
|
func NewClient(clientID, clientSecret string) (*Client, error) {
|
|
apiClient, err := helix.NewClient(&helix.Options{
|
|
ClientID: clientID,
|
|
ClientSecret: clientSecret,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
resp, err := apiClient.RequestAppAccessToken([]string{})
|
|
if err != nil || resp.StatusCode != 200 {
|
|
return nil, fmt.Errorf("Failed to get app access token: %v", err)
|
|
}
|
|
apiClient.SetUserAccessToken(resp.Data.AccessToken)
|
|
|
|
return &Client{api: apiClient}, nil
|
|
}
|
|
|
|
// Twitch API helpers
|
|
|
|
func (c *Client) GetUserID(login string) (string, error) {
|
|
resp, err := c.api.GetUsers(&helix.UsersParams{
|
|
Logins: []string{login},
|
|
})
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if len(resp.Data.Users) == 0 {
|
|
return "", fmt.Errorf("User not found")
|
|
}
|
|
return resp.Data.Users[0].ID, nil
|
|
}
|
|
|
|
func (c *Client) GetStreamInfo(userID string) (*helix.Stream, error) {
|
|
rep, err := c.api.GetStreams(&helix.StreamsParams{
|
|
UserIDs: []string{userID},
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(resp.Data.Streams) == 0 {
|
|
return nil, fmt.Errorf("Stream Is NOT LIVE")
|
|
}
|
|
return &resp.Data.Streams[0], nil
|
|
}
|
|
|
|
func (c *Client) GetStreamUptime(channel string) (string, error) {
|
|
userID, err := c.GetUserId(channel)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
stream, err := c.GetStreamInfo(userID)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
startedAt := stream.StartedAt
|
|
|
|
uptime := time.Since(startedAt).Round(time.Second)
|
|
return uptime.String(), nil
|
|
}
|
|
|
|
func (c *Client) GetStreamTitle(channel string) (string, error) {
|
|
userID, err := C. GetUserID(channel)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
resp, err := c.api.GetChannelInformation(&helix.GetChannelInformationParams{
|
|
BroadcasterID: userID,
|
|
})
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if len(resp.Data.Channels) == 0 {
|
|
return "", fmt.Errorf("Channel NOT found")
|
|
}
|
|
return resp.Data.Channels[0].Title, nil
|
|
}
|
|
|
|
func (c *Client) SetStreamTitle(channel, newTitle string) error {
|
|
userID, err := c.GetUserID(channel)
|
|
if err!= nil {
|
|
return err
|
|
}
|
|
_, err = c.api.EditChannelInformation(&helix.EditChannelInformationParams {
|
|
BroadcasterID: userID,
|
|
Title: newTitle,
|
|
})
|
|
return err
|
|
}
|
|
|
|
func (c *Client) GetStreamCategory(channel string) (string, error) {
|
|
userID, err := c.GetUserID(channel)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
resp, err := c.api.GetChannelInformation(&helix.GetChannelInformationParams{
|
|
BroadcasterID: userID,
|
|
})
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if len(resp.Data.Channels) == 0 {
|
|
return "", fmt.Errorf("Channel NOT found")
|
|
}
|
|
return resp.Data.Channels[0].GameName, nil
|
|
}
|
|
|
|
func setStreamCategory(client *helix.Client, channel, newCategory string) error {
|
|
userID, err := GetUserID(client, channel)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// get Twitch GameID by Name from API
|
|
gameID, err := getGameIDByName(client, newCategory)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = client.EditChannelInformation(&helix.EditChannelInformationParams{
|
|
BroadcasterID: userID,
|
|
GameID: gameID,
|
|
})
|
|
return err
|
|
}
|
|
|
|
func getGameIDByName(client *helix.Client, name string) (string, error) {
|
|
resp, err := GetGames(&helix.GamesParams{
|
|
Names: []string{name},
|
|
})
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if len(resp.Data.Games) == 0 {
|
|
return "", fmt.Errorf("Game NOT found")
|
|
}
|
|
return resp.Data.Games[0].ID, nil
|
|
}
|