mirror of
https://codeberg.org/SafeTwitch/safetwitch-backend.git
synced 2024-12-22 21:23:01 -05:00
582 lines
15 KiB
Go
582 lines
15 KiB
Go
package twitch
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"safetwitch-backend/extractor"
|
|
"safetwitch-backend/extractor/structs"
|
|
"strings"
|
|
|
|
"github.com/tidwall/gjson"
|
|
)
|
|
|
|
const twitchUrl = "https://gql.twitch.tv/gql"
|
|
|
|
var language string = "en"
|
|
|
|
// useful funcs
|
|
func SetLanguage(code string) {
|
|
language = code
|
|
}
|
|
|
|
func call(url, method string, body io.Reader) (*http.Response, error) {
|
|
req, err := http.NewRequest(method, url, body)
|
|
if err != nil {
|
|
return req.Response, err
|
|
}
|
|
|
|
req.Header.Add("Accept-Language", language)
|
|
req.Header.Add("Client-Id", "ue6666qo983tsx6so1t0vnawi233wa")
|
|
resp, err := http.DefaultClient.Do(req)
|
|
return resp, err
|
|
}
|
|
|
|
func parseResponse(payload []TwitchPayload) (response *[]structs.TwitchApiResponse, body []byte, err error) {
|
|
json_data, err := json.Marshal(payload)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
resp, err := call(twitchUrl, "POST", bytes.NewBuffer(json_data))
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
rawBody, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
var twitchResponse []structs.TwitchApiResponse
|
|
err = json.Unmarshal(rawBody, &twitchResponse)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
return &twitchResponse, rawBody, nil
|
|
}
|
|
|
|
type TwitchPayload = map[string]interface{}
|
|
|
|
func GetStreamerInfo(streamerName string) (structs.Streamer, error) {
|
|
payload := []TwitchPayload{
|
|
// Streamer data
|
|
{
|
|
"operationName": "ChannelRoot_AboutPanel",
|
|
"variables": map[string]interface{}{
|
|
"channelLogin": streamerName,
|
|
"skipSchedule": false,
|
|
},
|
|
"extensions": map[string]interface{}{
|
|
"persistedQuery": map[string]interface{}{
|
|
"version": 1,
|
|
"sha256Hash": "6089531acef6c09ece01b440c41978f4c8dc60cb4fa0124c9a9d3f896709b6c6",
|
|
},
|
|
},
|
|
},
|
|
|
|
// Stream metadata
|
|
{
|
|
"operationName": "StreamMetadata",
|
|
"variables": map[string]interface{}{
|
|
"channelLogin": streamerName,
|
|
},
|
|
"extensions": map[string]interface{}{
|
|
"persistedQuery": map[string]interface{}{
|
|
"version": 1,
|
|
"sha256Hash": "a647c2a13599e5991e175155f798ca7f1ecddde73f7f341f39009c14dbf59962",
|
|
},
|
|
},
|
|
},
|
|
|
|
// Stream tags
|
|
{
|
|
"operationName": "StreamTagsTrackingChannel",
|
|
"variables": map[string]interface{}{
|
|
"channel": streamerName,
|
|
},
|
|
"extensions": map[string]interface{}{
|
|
"persistedQuery": map[string]interface{}{
|
|
"version": 1,
|
|
"sha256Hash": "6aa3851aaaf88c320d514eb173563d430b28ed70fdaaf7eeef6ed4b812f48608",
|
|
},
|
|
},
|
|
},
|
|
|
|
// Stream preview image
|
|
{
|
|
"operationName": "VideoPreviewOverlay",
|
|
"variables": map[string]interface{}{
|
|
"login": streamerName,
|
|
},
|
|
"extensions": map[string]interface{}{
|
|
"persistedQuery": map[string]interface{}{
|
|
"version": 1,
|
|
"sha256Hash": "9515480dee68a77e667cb19de634739d33f243572b007e98e67184b1a5d8369f",
|
|
},
|
|
},
|
|
},
|
|
|
|
// Current views
|
|
{
|
|
"operationName": "UseViewCount",
|
|
"variables": map[string]interface{}{
|
|
"channelLogin": streamerName,
|
|
},
|
|
"extensions": map[string]interface{}{
|
|
"persistedQuery": map[string]interface{}{
|
|
"version": 1,
|
|
"sha256Hash": "00b11c9c428f79ae228f30080a06ffd8226a1f068d6f52fbc057cbde66e994c2",
|
|
},
|
|
},
|
|
},
|
|
|
|
// Get offline banner image
|
|
{
|
|
"operationName": "ChannelShell",
|
|
"variables": map[string]interface{}{
|
|
"login": streamerName,
|
|
},
|
|
"extensions": map[string]interface{}{
|
|
"persistedQuery": map[string]interface{}{
|
|
"version": 1,
|
|
"sha256Hash": "580ab410bcd0c1ad194224957ae2241e5d252b2c5173d8e0cce9d32d5bb14efe",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
_, body, err := parseResponse(payload)
|
|
if err != nil {
|
|
return structs.Streamer{}, err
|
|
}
|
|
|
|
// begin parsing response
|
|
streamerFound := gjson.Get(string(body), "0.data.user")
|
|
if streamerFound.String() == "" {
|
|
return structs.Streamer{}, errors.New("streamer not found")
|
|
}
|
|
|
|
streamerData := gjson.Get(string(body), "0.data")
|
|
parsedSocials, err := ParseSocials(streamerData.String())
|
|
if err != nil {
|
|
return structs.Streamer{}, err
|
|
}
|
|
|
|
parsedStream, err := ParseStream(string(body))
|
|
var isLive bool
|
|
if err != nil {
|
|
if err.Error() == "streamer is not live" {
|
|
parsedStream = nil
|
|
} else {
|
|
return structs.Streamer{}, err
|
|
}
|
|
}
|
|
if parsedStream != nil {
|
|
isLive = true
|
|
} else {
|
|
isLive = false
|
|
}
|
|
|
|
streamerBanner := gjson.Get(string(body), "5.data.userOrError.bannerImageURL").String()
|
|
|
|
parsedStreamer, err := ParseStreamer(streamerData, isLive, parsedSocials, parsedStream, streamerName, streamerBanner)
|
|
if err != nil {
|
|
return structs.Streamer{}, err
|
|
}
|
|
|
|
return parsedStreamer, nil
|
|
}
|
|
|
|
func GetDiscoveryPage(limit int, cursor string) ([]structs.CategoryPreview, error) {
|
|
payload := []TwitchPayload{
|
|
{
|
|
"operationName": "BrowsePage_AllDirectories",
|
|
"variables": map[string]interface{}{
|
|
"limit": limit,
|
|
"options": map[string]interface{}{
|
|
"recommendationsContext": map[string]interface{}{
|
|
"platform": "web",
|
|
},
|
|
"requestID": "JIRA-VXP-2397",
|
|
"sort": "RELEVANCE",
|
|
"tags": []string{},
|
|
},
|
|
"cursor": cursor,
|
|
},
|
|
"extensions": map[string]interface{}{
|
|
"persistedQuery": map[string]interface{}{
|
|
"version": 1,
|
|
"sha256Hash": "1d1914ca3cbfaa607ecd5595b2e305e96acf987c8f25328f7713b25f604c4668",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
_, body, err := parseResponse(payload)
|
|
if err != nil {
|
|
return []structs.CategoryPreview{}, err
|
|
}
|
|
|
|
var parsedCategoryArray []structs.CategoryPreview
|
|
categoryArray := gjson.Get(string(body), "0.data.directoriesWithTags.edges")
|
|
for _, categoryRes := range categoryArray.Array() {
|
|
parsedCategory, err := ParseCategory(categoryRes)
|
|
if err != nil {
|
|
return []structs.CategoryPreview{}, nil
|
|
}
|
|
|
|
parsedCategoryArray = append(parsedCategoryArray, parsedCategory)
|
|
}
|
|
|
|
return parsedCategoryArray, nil
|
|
}
|
|
|
|
func GetDiscoveryItem(name string, streamLimit int, cursor string) (structs.CategoryData, error) {
|
|
payload := []TwitchPayload{
|
|
{
|
|
"operationName": "DirectoryPage_Game",
|
|
"variables": map[string]interface{}{
|
|
"cursor": cursor,
|
|
"imageWidth": 50,
|
|
"name": name,
|
|
"options": map[string]interface{}{
|
|
"sort": "RELEVANCE",
|
|
"recommendationsContext": map[string]interface{}{
|
|
"platform": "web",
|
|
},
|
|
"requestID": "JIRA-VXP-2397",
|
|
"freeformTags": nil,
|
|
"tags": []string{},
|
|
},
|
|
"sortTypeIsRecency": false,
|
|
"limit": streamLimit,
|
|
},
|
|
"extensions": map[string]interface{}{
|
|
"persistedQuery": map[string]interface{}{
|
|
"version": 1,
|
|
"sha256Hash": "df4bb6cc45055237bfaf3ead608bbafb79815c7100b6ee126719fac3762ddf8b",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
"operationName": "Directory_DirectoryBanner",
|
|
"variables": map[string]interface{}{
|
|
"name": name,
|
|
},
|
|
"extensions": map[string]interface{}{
|
|
"persistedQuery": map[string]interface{}{
|
|
"version": 1,
|
|
"sha256Hash": "2670fbecd8fbea0211c56528d6eff5752ef9d6c73cd5238d395784b46335ded4",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
_, body, err := parseResponse(payload)
|
|
if err != nil {
|
|
return structs.CategoryData{}, err
|
|
}
|
|
|
|
categoryStreams := gjson.Get(string(body), "0.data.game.streams.edges")
|
|
|
|
var parsedStreams []structs.CategoryMinifiedStream
|
|
for _, stream := range categoryStreams.Array() {
|
|
parsed, err := ParseMinifiedStream(stream)
|
|
if err != nil {
|
|
return structs.CategoryData{}, err
|
|
}
|
|
parsedStreams = append(parsedStreams, parsed)
|
|
}
|
|
|
|
categoryData := gjson.Get(string(body), "1.data.game")
|
|
|
|
var tags []string
|
|
for _, tag := range categoryData.Get("tags").Array() {
|
|
tags = append(tags, tag.Get("localizedName").String())
|
|
}
|
|
|
|
parsedCategory := structs.CategoryData{
|
|
Name: categoryData.Get("name").String(),
|
|
DisplayName: categoryData.Get("displayName").String(),
|
|
Description: categoryData.Get("description").String(),
|
|
Viewers: int(categoryData.Get("viewersCount").Int()),
|
|
Followers: int(categoryData.Get("followersCount").Int()),
|
|
Tags: tags,
|
|
Cover: extractor.ProxyUrl(categoryData.Get("avatarURL").String()),
|
|
Streams: parsedStreams,
|
|
}
|
|
|
|
return parsedCategory, err
|
|
}
|
|
|
|
func GetTwitchBadges() ([]structs.Badge, error) {
|
|
payload := []TwitchPayload{
|
|
{
|
|
"operationName": "ChannelPointsPredictionBadges",
|
|
"variables": map[string]interface{}{},
|
|
"extensions": map[string]interface{}{
|
|
"persistedQuery": map[string]interface{}{
|
|
"sha256Hash": "36995b30b22c31d1cd0aa329987ac9b5368bb7e6e1ab1df42808bdaa80a6dbf9",
|
|
"version": 1,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
_, body, err := parseResponse(payload)
|
|
if err != nil {
|
|
return []structs.Badge{}, err
|
|
}
|
|
|
|
rawBadges := gjson.Get(string(body), "0.data.badges")
|
|
formattedBadges, err := ParseBadges(rawBadges)
|
|
if err != nil {
|
|
return []structs.Badge{}, err
|
|
}
|
|
|
|
return formattedBadges, nil
|
|
}
|
|
|
|
func GetStreamerBadges(streamerName string) ([]structs.Badge, error) {
|
|
payload := []TwitchPayload{
|
|
{
|
|
"extensions": map[string]interface{}{
|
|
"persistedQuery": map[string]interface{}{
|
|
"sha256Hash": "86f43113c04606e6476e39dcd432dee47c994d77a83e54b732e11d4935f0cd08",
|
|
"version": 1,
|
|
},
|
|
},
|
|
"operationName": "ChatList_Badges",
|
|
"variables": map[string]interface{}{
|
|
"channelLogin": streamerName,
|
|
},
|
|
},
|
|
}
|
|
|
|
_, body, err := parseResponse(payload)
|
|
if err != nil {
|
|
return []structs.Badge{}, err
|
|
}
|
|
|
|
rawBadges := gjson.Get(string(body), "0.data.user.broadcastBadges")
|
|
|
|
formattedBadges, err := ParseBadges(rawBadges)
|
|
if err != nil {
|
|
return []structs.Badge{}, err
|
|
}
|
|
|
|
return formattedBadges, nil
|
|
}
|
|
|
|
func GetStream(streamerName string) (string, error) {
|
|
// STAGE 1
|
|
// Get playback token from twitch
|
|
// Same request browser makes
|
|
payload1 := []TwitchPayload{
|
|
{
|
|
"extensions": map[string]interface{}{
|
|
"persistedQuery": map[string]interface{}{
|
|
"version": 1,
|
|
"sha256Hash": "0828119ded1c13477966434e15800ff57ddacf13ba1911c129dc2200705b0712",
|
|
},
|
|
},
|
|
"operationName": "PlaybackAccessToken",
|
|
"variables": map[string]interface{}{
|
|
"isLive": true,
|
|
"login": streamerName,
|
|
"isVod": false,
|
|
"vodID": "",
|
|
"playerType": "site",
|
|
},
|
|
},
|
|
}
|
|
|
|
_, body, err := parseResponse(payload1)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
// These will be needed to get playlist file from twitch
|
|
token := gjson.Get(string(body), "0.data.streamPlaybackAccessToken.value").String()
|
|
signature := gjson.Get(string(body), "0.data.streamPlaybackAccessToken.signature").String()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
playlistUrl := "https://usher.ttvnw.net/api/channel/hls/" + strings.ToLower(streamerName) + ".m3u8"
|
|
params := "?sig=" + signature + "&token=" + token
|
|
|
|
req, err := http.NewRequest("GET", playlistUrl+params, nil)
|
|
req.Header.Add("Client-Id", "ue6666qo983tsx6so1t0vnawi233wa")
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
playlistFile, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// holy zooks, what the scallop??? we got the playlist, houston!!!
|
|
// time to proxy all the urls!!!
|
|
proxiedPlaylist := ProxyPlaylistFile(string(playlistFile), false)
|
|
return proxiedPlaylist, nil
|
|
|
|
}
|
|
|
|
func GetSubPlaylist(rawurl string) (string, error) {
|
|
req, err := http.NewRequest("GET", rawurl, nil)
|
|
|
|
req.Header.Add("Client-Id", "ue6666qo983tsx6so1t0vnawi233wa")
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
playlistFile, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
proxiedPlaylist := ProxyPlaylistFile(string(playlistFile), true)
|
|
return proxiedPlaylist, nil
|
|
}
|
|
|
|
func GetSearchResult(query string) (structs.SearchResult, error) {
|
|
payload := []TwitchPayload{
|
|
{
|
|
"operationName": "SearchResultsPage_SearchResults",
|
|
"variables": map[string]interface{}{
|
|
"query": query,
|
|
"options": nil,
|
|
"requestID": "75948144-d051-4203-8511-57f3ee9b809a",
|
|
},
|
|
"extensions": map[string]interface{}{
|
|
"persistedQuery": map[string]interface{}{
|
|
"version": 1,
|
|
"sha256Hash": "6ea6e6f66006485e41dbe3ebd69d5674c5b22896ce7b595d7fce6411a3790138",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
_, body, err := parseResponse(payload)
|
|
if err != nil {
|
|
return structs.SearchResult{}, err
|
|
}
|
|
|
|
rawStreamers := gjson.Get(string(body), "0.data.searchFor.channels.edges")
|
|
parsedStreamers := []structs.Streamer{}
|
|
for _, streamer := range rawStreamers.Array() {
|
|
stream := streamer.Get("item.stream").String()
|
|
|
|
parsedStreamers = append(parsedStreamers, structs.Streamer{
|
|
Username: streamer.Get("item.login").String(),
|
|
Followers: int(streamer.Get("item.followers.totalCount").Int()),
|
|
IsLive: !(stream == ""),
|
|
About: streamer.Get("item.description").String(),
|
|
Pfp: extractor.ProxyUrl(streamer.Get("item.prifileImageURL").String()),
|
|
IsPartner: false,
|
|
ColorHex: nil,
|
|
Id: streamer.Get("item.channel.id").String(),
|
|
})
|
|
}
|
|
|
|
parsedCategories := []structs.CategoryPreview{}
|
|
rawCategories := gjson.Get(string(body), "0.data.searchFor.games.edges")
|
|
|
|
for _, category := range rawCategories.Array() {
|
|
var tags []string
|
|
for _, tag := range category.Get("item.tags").Array() {
|
|
tags = append(tags, tag.Get("tagName").String())
|
|
}
|
|
|
|
parsedCategories = append(parsedCategories, structs.CategoryPreview{
|
|
Name: category.Get("item.name").String(),
|
|
DisplayName: category.Get("item.displayName").String(),
|
|
Viewers: int(category.Get("item.viewersCount").Int()),
|
|
Image: category.Get("item.boxArtURL").String(),
|
|
Tags: tags,
|
|
})
|
|
}
|
|
|
|
foundRelatedLiveChannels := []structs.Streamer{}
|
|
streams := gjson.Get(string(body), "0.data.searchFor.relatedLiveChannels.edges")
|
|
for _, channel := range streams.Array() {
|
|
name := channel.Get("item.stream.broadcaster.login").String()
|
|
channel, err := GetStreamerInfo(name)
|
|
if err != nil {
|
|
return structs.SearchResult{}, nil
|
|
}
|
|
foundRelatedLiveChannels = append(foundRelatedLiveChannels, channel)
|
|
}
|
|
|
|
foundChannelsWithTag := []structs.Streamer{}
|
|
streams = gjson.Get(string(body), "0.data.searchFor.channelsWithTag.edges")
|
|
for _, stream := range streams.Array() {
|
|
foundChannelsWithTag = append(foundChannelsWithTag, structs.Streamer{
|
|
Username: stream.Get("item.login").String(),
|
|
Followers: int(stream.Get("item.followers.totalCount").Int()),
|
|
IsLive: !(stream.Get("stream").String() != ""),
|
|
About: stream.Get("item.description").String(),
|
|
Pfp: extractor.ProxyUrl(stream.Get("item.profileImageURL").String()),
|
|
IsPartner: false,
|
|
ColorHex: nil,
|
|
Id: stream.Get("item.channel.id").String(),
|
|
})
|
|
}
|
|
|
|
final := structs.SearchResult{
|
|
Channels: parsedStreamers,
|
|
Categories: parsedCategories,
|
|
RelatedLiveChannels: foundRelatedLiveChannels,
|
|
ChannelsWithTag: foundChannelsWithTag,
|
|
}
|
|
|
|
return final, nil
|
|
|
|
}
|
|
|
|
func GetStreamerId(channelName string) (string, error) {
|
|
payload := []TwitchPayload{
|
|
{
|
|
"operationName": "ChannelRoot_AboutPanel",
|
|
"variables": map[string]interface{}{
|
|
"channelLogin": channelName,
|
|
"skipSchedule": true,
|
|
},
|
|
"extensions": map[string]interface{}{
|
|
"persistedQuery": map[string]interface{}{
|
|
"version": 1,
|
|
"sha256Hash": "6089531acef6c09ece01b440c41978f4c8dc60cb4fa0124c9a9d3f896709b6c6",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
_, body, err := parseResponse(payload)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
id := gjson.Get(string(body), "0.data.user.id").String()
|
|
|
|
if id != "" {
|
|
return id, nil
|
|
} else {
|
|
return "", errors.New("could not find user")
|
|
}
|
|
}
|