727 lines
18 KiB
Go
727 lines
18 KiB
Go
package crawler
|
||
|
||
import (
|
||
"bytes"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"net/url"
|
||
"regexp"
|
||
"runtime/debug"
|
||
"strconv"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
|
||
"pcgamedb/cache"
|
||
"pcgamedb/config"
|
||
"pcgamedb/constant"
|
||
"pcgamedb/db"
|
||
"pcgamedb/model"
|
||
"pcgamedb/utils"
|
||
|
||
"github.com/PuerkitoBio/goquery"
|
||
)
|
||
|
||
type twitchToken struct {
|
||
Token string `json:"token"`
|
||
Expires time.Time `json:"expires"`
|
||
once sync.Once
|
||
}
|
||
|
||
var token = twitchToken{}
|
||
|
||
func (t *twitchToken) getToken() (string, error) {
|
||
t.once.Do(func() {
|
||
if config.Config.RedisAvaliable {
|
||
if dataBytes, exist := cache.Get("twitch_token"); exist {
|
||
_ = json.Unmarshal([]byte(dataBytes), &token)
|
||
}
|
||
}
|
||
})
|
||
if t.Token == "" || time.Now().After(t.Expires) {
|
||
token, expires, err := loginTwitch()
|
||
if err != nil {
|
||
return "", fmt.Errorf("failed to login twitch: %w", err)
|
||
}
|
||
t.Token = token
|
||
t.Expires = expires
|
||
j, err := json.Marshal(t)
|
||
if err == nil {
|
||
_ = cache.Add("twitch_token", j)
|
||
}
|
||
}
|
||
return t.Token, nil
|
||
}
|
||
|
||
func loginTwitch() (string, time.Time, error) {
|
||
baseURL, _ := url.Parse(constant.TwitchAuthURL)
|
||
params := url.Values{}
|
||
params.Add("client_id", config.Config.Twitch.ClientID)
|
||
params.Add("client_secret", config.Config.Twitch.ClientSecret)
|
||
params.Add("grant_type", "client_credentials")
|
||
baseURL.RawQuery = params.Encode()
|
||
resp, err := utils.Fetch(utils.FetchConfig{
|
||
Url: baseURL.String(),
|
||
Method: "POST",
|
||
Headers: map[string]string{
|
||
"User-Agent": "",
|
||
},
|
||
})
|
||
if err != nil {
|
||
return "", time.Time{}, err
|
||
}
|
||
data := struct {
|
||
AccessToken string `json:"access_token"`
|
||
ExpiresIn int64 `json:"expires_in"`
|
||
TokenType string `json:"token_type"`
|
||
}{}
|
||
err = json.Unmarshal(resp.Data, &data)
|
||
if err != nil {
|
||
return "", time.Time{}, err
|
||
}
|
||
return data.AccessToken, time.Now().Add(time.Second * time.Duration(data.ExpiresIn)), nil
|
||
}
|
||
|
||
func igdbFetch(URL string, dataBody any) (*utils.FetchResponse, error) {
|
||
t, err := token.getToken()
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
resp, err := utils.Fetch(utils.FetchConfig{
|
||
Url: URL,
|
||
Headers: map[string]string{
|
||
"Client-ID": config.Config.Twitch.ClientID,
|
||
"Authorization": "Bearer " + t,
|
||
"User-Agent": "",
|
||
"Content-Type": "text/plain",
|
||
},
|
||
Data: dataBody,
|
||
Method: "POST",
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return resp, nil
|
||
}
|
||
|
||
func getIGDBID(name string) (int, error) {
|
||
var err error
|
||
resp, err := igdbFetch(constant.IGDBSearchURL, fmt.Sprintf(`search "%s"; fields *; limit 50; where game.platforms = [6] | game.platforms=[130] | game.platforms=[384] | game.platforms=[163];`, name))
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
if string(resp.Data) == "[]" {
|
||
resp, err = igdbFetch(constant.IGDBSearchURL, fmt.Sprintf(`search "%s"; fields *; limit 50;`, name))
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
}
|
||
|
||
var data model.IGDBSearches
|
||
if err = json.Unmarshal(resp.Data, &data); err != nil {
|
||
return 0, fmt.Errorf("failed to unmarshal: %w, %s", err, debug.Stack())
|
||
}
|
||
if len(data) == 1 {
|
||
return GetIGDBAppParentCache(data[0].Game)
|
||
}
|
||
maxSimilairty := 0.0
|
||
maxSimilairtyIndex := 0
|
||
for i, item := range data {
|
||
if strings.EqualFold(item.Name, name) {
|
||
return item.Game, nil
|
||
}
|
||
if sim := utils.Similarity(name, item.Name); sim >= 0.8 {
|
||
if sim > maxSimilairty {
|
||
maxSimilairty = sim
|
||
maxSimilairtyIndex = i
|
||
}
|
||
}
|
||
detail, err := GetIGDBAppDetailCache(item.Game)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
for _, alternativeNames := range detail.AlternativeNames {
|
||
if sim := utils.Similarity(alternativeNames.Name, name); sim >= 0.8 {
|
||
if sim > maxSimilairty {
|
||
maxSimilairty = sim
|
||
maxSimilairtyIndex = i
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if maxSimilairty >= 0.8 {
|
||
return GetIGDBAppParentCache(data[maxSimilairtyIndex].Game)
|
||
}
|
||
return 0, fmt.Errorf("IGDB ID not found: %s", name)
|
||
}
|
||
|
||
func getIGDBIDBySteamSearch(name string) (int, error) {
|
||
baseURL, _ := url.Parse(constant.SteamSearchURL)
|
||
params := url.Values{}
|
||
params.Add("term", name)
|
||
baseURL.RawQuery = params.Encode()
|
||
|
||
resp, err := utils.Fetch(utils.FetchConfig{
|
||
Url: baseURL.String(),
|
||
})
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
doc, err := goquery.NewDocumentFromReader(bytes.NewReader(resp.Data))
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
type searchResult struct {
|
||
ID int
|
||
Type string
|
||
Name string
|
||
}
|
||
var items []searchResult
|
||
doc.Find(".search_result_row").Each(func(i int, s *goquery.Selection) {
|
||
if itemKey, exist := s.Attr("data-ds-itemkey"); exist {
|
||
if strings.HasPrefix(itemKey, "App_") {
|
||
id, err := strconv.Atoi(itemKey[4:])
|
||
if err != nil {
|
||
return
|
||
}
|
||
name := s.Find(".title").Text()
|
||
items = append(items, searchResult{
|
||
ID: id,
|
||
Type: "App",
|
||
Name: name,
|
||
})
|
||
}
|
||
if strings.HasPrefix(itemKey, "Bundle_") {
|
||
id, err := strconv.Atoi(itemKey[7:])
|
||
if err != nil {
|
||
return
|
||
}
|
||
name := s.Find(".title").Text()
|
||
items = append(items, searchResult{
|
||
ID: id,
|
||
Type: "Bundle",
|
||
Name: name,
|
||
})
|
||
}
|
||
}
|
||
})
|
||
|
||
maxSim := 0.0
|
||
var maxSimItem searchResult
|
||
for _, item := range items {
|
||
if strings.EqualFold(strings.TrimSpace(item.Name), strings.TrimSpace(name)) {
|
||
maxSimItem = item
|
||
break
|
||
} else {
|
||
sim := utils.Similarity(item.Name, name)
|
||
if sim >= 0.8 && sim > maxSim {
|
||
maxSim = sim
|
||
maxSimItem = item
|
||
}
|
||
}
|
||
}
|
||
if maxSim != 0 {
|
||
if maxSimItem.Type == "App" {
|
||
return GetIGDBIDBySteamAppIDCache(maxSimItem.ID)
|
||
}
|
||
if maxSimItem.Type == "Bundle" {
|
||
return GetIGDBIDBySteamBundleIDCache(maxSimItem.ID)
|
||
}
|
||
}
|
||
return 0, fmt.Errorf("steam ID not found: %s", name)
|
||
}
|
||
|
||
// GetIGDBAppParent returns the parent of the game, if no parent return itself
|
||
func GetIGDBAppParent(id int) (int, error) {
|
||
detail, err := GetIGDBAppDetailCache(id)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
hasParent := false
|
||
for detail.VersionParent != 0 {
|
||
hasParent = true
|
||
detail, err = GetIGDBAppDetailCache(detail.VersionParent)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
}
|
||
if hasParent {
|
||
return detail.ID, nil
|
||
}
|
||
return id, nil
|
||
}
|
||
|
||
func GetIGDBAppParetns(ids []int) (map[int]int, error) {
|
||
var err error
|
||
idsStr := make([]string, len(ids))
|
||
for i, id := range ids {
|
||
idsStr[i] = strconv.Itoa(id)
|
||
}
|
||
resp, err := igdbFetch(constant.IGDBGameURL, fmt.Sprintf(`where id=(%s) ;fields version_parent;`, strings.Join(idsStr, ",")))
|
||
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
var data []struct {
|
||
ID int `json:"id"`
|
||
VersionParent int `json:"version_parent"`
|
||
}
|
||
if err = json.Unmarshal(resp.Data, &data); err != nil {
|
||
return nil, fmt.Errorf("failed to unmarshal: %w, %s", err, debug.Stack())
|
||
}
|
||
parents := make(map[int]int)
|
||
for _, item := range data {
|
||
if item.VersionParent != 0 {
|
||
pid, err := GetIGDBAppParentCache(item.VersionParent)
|
||
if err != nil {
|
||
parents[item.ID] = item.ID
|
||
} else {
|
||
parents[item.ID] = pid
|
||
}
|
||
} else {
|
||
parents[item.ID] = item.ID
|
||
}
|
||
}
|
||
return parents, nil
|
||
}
|
||
|
||
func GetIGDBAppParentCache(id int) (int, error) {
|
||
if config.Config.RedisAvaliable {
|
||
key := fmt.Sprintf("igdb_parent:%d", id)
|
||
val, exist := cache.Get(key)
|
||
if exist {
|
||
id, err := strconv.Atoi(val)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
return id, nil
|
||
} else {
|
||
id, err := GetIGDBAppParent(id)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
_ = cache.Add(key, id)
|
||
return id, nil
|
||
}
|
||
}
|
||
return GetIGDBAppParent(id)
|
||
}
|
||
|
||
// GetIGDBID returns the IGDB ID of the game, try directly IGDB api first, then steam search
|
||
func GetIGDBID(name string) (int, error) {
|
||
name1 := name
|
||
name2 := FormatName(name)
|
||
names := []string{name1}
|
||
if name1 != name2 {
|
||
names = append(names, name2)
|
||
}
|
||
for _, name := range names {
|
||
id, err := getIGDBID(name)
|
||
if err == nil {
|
||
return id, nil
|
||
}
|
||
}
|
||
for _, name := range names {
|
||
id, err := getIGDBIDBySteamSearch(name)
|
||
if err == nil {
|
||
return id, nil
|
||
}
|
||
}
|
||
return 0, errors.New("IGDB ID not found")
|
||
}
|
||
|
||
func GetIGDBIDCache(name string) (int, error) {
|
||
if config.Config.RedisAvaliable {
|
||
key := fmt.Sprintf("igdb_id:%s", name)
|
||
val, exist := cache.Get(key)
|
||
if exist {
|
||
id, err := strconv.Atoi(val)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
return id, nil
|
||
} else {
|
||
id, err := GetIGDBID(name)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
_ = cache.Add(key, id)
|
||
return id, nil
|
||
}
|
||
} else {
|
||
return GetIGDBID(name)
|
||
}
|
||
}
|
||
|
||
func GetIGDBAppDetail(id int) (*model.IGDBGameDetail, error) {
|
||
var err error
|
||
resp, err := igdbFetch(constant.IGDBGameURL, fmt.Sprintf(`where id=%v ;fields *,alternative_names.name,language_supports.language,language_supports.language_support_type,screenshots.url,cover.url,involved_companies.company,involved_companies.developer,involved_companies.publisher;`, id))
|
||
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
var data model.IGDBGameDetails
|
||
if err = json.Unmarshal(resp.Data, &data); err != nil {
|
||
return nil, err
|
||
}
|
||
if len(data) == 0 {
|
||
return nil, errors.New("IGDB App not found")
|
||
}
|
||
if data[0].Name == "" {
|
||
return GetIGDBAppDetail(id)
|
||
}
|
||
return data[0], nil
|
||
}
|
||
|
||
func GetIGDBAppDetailCache(id int) (*model.IGDBGameDetail, error) {
|
||
if config.Config.RedisAvaliable {
|
||
key := fmt.Sprintf("igdb_game:%v", id)
|
||
val, exist := cache.Get(key)
|
||
if exist {
|
||
var data model.IGDBGameDetail
|
||
if err := json.Unmarshal([]byte(val), &data); err != nil {
|
||
return nil, err
|
||
}
|
||
return &data, nil
|
||
} else {
|
||
data, err := GetIGDBAppDetail(id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
dataBytes, err := json.Marshal(data)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
_ = cache.AddWithExpire(key, dataBytes, 7*24*time.Hour)
|
||
return data, nil
|
||
}
|
||
} else {
|
||
return GetIGDBAppDetail(id)
|
||
}
|
||
}
|
||
|
||
func GetIGDBCompany(id int) (string, error) {
|
||
var err error
|
||
resp, err := igdbFetch(constant.IGDBCompaniesURL, fmt.Sprintf(`where id=%v; fields *;`, id))
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
var data model.IGDBCompanies
|
||
if err = json.Unmarshal(resp.Data, &data); err != nil {
|
||
return "", err
|
||
}
|
||
if len(data) == 0 {
|
||
return "", errors.New("not found")
|
||
}
|
||
if data[0].Name == "" {
|
||
return GetIGDBCompany(id)
|
||
}
|
||
return data[0].Name, nil
|
||
}
|
||
|
||
func GetIGDBCompanyCache(id int) (string, error) {
|
||
if config.Config.RedisAvaliable {
|
||
key := fmt.Sprintf("igdb_companies:%v", id)
|
||
val, exist := cache.Get(key)
|
||
if exist {
|
||
return val, nil
|
||
} else {
|
||
data, err := GetIGDBCompany(id)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
_ = cache.Add(key, data)
|
||
return data, nil
|
||
}
|
||
} else {
|
||
return GetIGDBCompany(id)
|
||
}
|
||
}
|
||
|
||
func GenerateIGDBGameInfo(id int) (*model.GameInfo, error) {
|
||
item := &model.GameInfo{}
|
||
detail, err := GetIGDBAppDetailCache(id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
item.IGDBID = id
|
||
item.Name = detail.Name
|
||
item.Description = detail.Summary
|
||
item.Cover = strings.Replace(detail.Cover.URL, "t_thumb", "t_original", 1)
|
||
item.InfoUpdatedAt = time.Now()
|
||
|
||
for _, lang := range detail.LanguageSupports {
|
||
if lang.LanguageSupportType == 3 {
|
||
l, exist := constant.IGDBLanguages[lang.Language]
|
||
if !exist {
|
||
continue
|
||
}
|
||
item.Languages = append(item.Languages, l.Name)
|
||
}
|
||
}
|
||
|
||
for _, screenshot := range detail.Screenshots {
|
||
item.Screenshots = append(item.Screenshots, strings.Replace(screenshot.URL, "t_thumb", "t_original", 1))
|
||
}
|
||
|
||
for _, alias := range detail.AlternativeNames {
|
||
item.Aliases = append(item.Aliases, alias.Name)
|
||
}
|
||
|
||
for _, company := range detail.InvolvedCompanies {
|
||
if company.Developer || company.Publisher {
|
||
companyName, err := GetIGDBCompanyCache(company.Company)
|
||
if err != nil {
|
||
continue
|
||
}
|
||
if company.Developer {
|
||
item.Developers = append(item.Developers, companyName)
|
||
}
|
||
if company.Publisher {
|
||
item.Publishers = append(item.Publishers, companyName)
|
||
}
|
||
}
|
||
}
|
||
|
||
return item, nil
|
||
}
|
||
|
||
// OrganizeGameItemWithIGDB Will add GameItem.ID to the newly added GameInfo.GameIDs
|
||
func OrganizeGameItemWithIGDB(game *model.GameItem) (*model.GameInfo, error) {
|
||
id, err := GetIGDBIDCache(game.Name)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
d, err := db.GetGameInfoByPlatformID("igdb", id)
|
||
if err == nil {
|
||
d.GameIDs = append(d.GameIDs, game.ID)
|
||
d.GameIDs = utils.Unique(d.GameIDs)
|
||
return d, nil
|
||
}
|
||
info, err := GenerateGameInfo("igdb", id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
info.GameIDs = append(info.GameIDs, game.ID)
|
||
info.GameIDs = utils.Unique(info.GameIDs)
|
||
return info, nil
|
||
}
|
||
|
||
func GetIGDBIDBySteamAppID(id int) (int, error) {
|
||
var err error
|
||
resp, err := igdbFetch(constant.IGDBWebsitesURL, fmt.Sprintf(`where url = "https://store.steampowered.com/app/%v" | url = "https://store.steampowered.com/app/%v/"*; fields *; limit 500;`, id, id))
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
var data []struct {
|
||
Game int `json:"game"`
|
||
}
|
||
if err = json.Unmarshal(resp.Data, &data); err != nil {
|
||
return 0, err
|
||
}
|
||
if len(data) == 0 {
|
||
return 0, errors.New("not found")
|
||
}
|
||
if data[0].Game == 0 {
|
||
return GetIGDBIDBySteamAppID(id)
|
||
}
|
||
return GetIGDBAppParentCache(data[0].Game)
|
||
}
|
||
|
||
func GetIGDBIDBySteamAppIDCache(id int) (int, error) {
|
||
if config.Config.RedisAvaliable {
|
||
key := fmt.Sprintf("igdb_id_by_steam_app_id:%v", id)
|
||
val, exist := cache.Get(key)
|
||
if exist {
|
||
return strconv.Atoi(val)
|
||
} else {
|
||
data, err := GetIGDBIDBySteamAppID(id)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
_ = cache.Add(key, strconv.Itoa(data))
|
||
return data, nil
|
||
}
|
||
} else {
|
||
return GetIGDBIDBySteamAppID(id)
|
||
}
|
||
}
|
||
|
||
func GetIGDBIDBySteamBundleID(id int) (int, error) {
|
||
var err error
|
||
resp, err := igdbFetch(constant.IGDBWebsitesURL, fmt.Sprintf(`where url = "https://store.steampowered.com/bundle/%v" | url = "https://store.steampowered.com/bundle/%v/"*; fields *; limit 500;`, id, id))
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
var data []struct {
|
||
Game int `json:"game"`
|
||
}
|
||
if err = json.Unmarshal(resp.Data, &data); err != nil {
|
||
return 0, err
|
||
}
|
||
if len(data) == 0 {
|
||
return 0, errors.New("not found")
|
||
}
|
||
if data[0].Game == 0 {
|
||
return GetIGDBIDBySteamBundleID(id)
|
||
}
|
||
return GetIGDBAppParentCache(data[0].Game)
|
||
}
|
||
|
||
func GetIGDBIDBySteamBundleIDCache(id int) (int, error) {
|
||
if config.Config.RedisAvaliable {
|
||
key := fmt.Sprintf("igdb_id_by_steam_bundle_id:%v", id)
|
||
val, exist := cache.Get(key)
|
||
if exist {
|
||
return strconv.Atoi(val)
|
||
} else {
|
||
data, err := GetIGDBIDBySteamBundleID(id)
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
_ = cache.Add(key, strconv.Itoa(data))
|
||
return data, nil
|
||
}
|
||
} else {
|
||
return GetIGDBIDBySteamBundleID(id)
|
||
}
|
||
}
|
||
|
||
func GetIGDBIDsBySteamIDs(ids []int) (map[int]int, error) {
|
||
var err error
|
||
conditionBuilder := strings.Builder{}
|
||
for _, id := range ids {
|
||
conditionBuilder.WriteString(fmt.Sprintf(`url = "https://store.steampowered.com/app/%v" | `, id))
|
||
conditionBuilder.WriteString(fmt.Sprintf(`url = "https://store.steampowered.com/app/%v/"* | `, id))
|
||
}
|
||
condition := strings.TrimSuffix(conditionBuilder.String(), " | ")
|
||
respBody := fmt.Sprintf(`where %s; fields *; limit 500;`, condition)
|
||
resp, err := igdbFetch(constant.IGDBWebsitesURL, respBody)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
var data []struct {
|
||
Game int `json:"game"`
|
||
Url string `json:"url"`
|
||
}
|
||
if err = json.Unmarshal(resp.Data, &data); err != nil {
|
||
return nil, err
|
||
}
|
||
ret := make(map[int]int)
|
||
regex := regexp.MustCompile(`https://store.steampowered.com/app/(\d+)/?`)
|
||
for _, d := range data {
|
||
idStr := regex.FindStringSubmatch(d.Url)
|
||
if len(idStr) < 2 {
|
||
continue
|
||
}
|
||
id, err := strconv.Atoi(idStr[1])
|
||
if err == nil {
|
||
pid, err := GetIGDBAppParentCache(d.Game)
|
||
if err == nil {
|
||
ret[id] = pid
|
||
} else {
|
||
ret[id] = 0
|
||
}
|
||
}
|
||
}
|
||
for _, id := range ids {
|
||
if _, ok := ret[id]; !ok {
|
||
ret[id] = 0
|
||
}
|
||
}
|
||
return ret, nil
|
||
}
|
||
|
||
func GetIGDBIDsBySteamIDsCache(ids []int) (map[int]int, error) {
|
||
res := make(map[int]int)
|
||
notExistIDs := make([]int, 0)
|
||
if config.Config.RedisAvaliable {
|
||
for _, steamID := range ids {
|
||
key := fmt.Sprintf("igdb_id_by_steam_id:%v", steamID)
|
||
val, exist := cache.Get(key)
|
||
if exist {
|
||
igdbID, _ := strconv.Atoi(val)
|
||
res[steamID] = igdbID
|
||
} else {
|
||
notExistIDs = append(notExistIDs, steamID)
|
||
}
|
||
}
|
||
if len(res) == len(ids) {
|
||
return res, nil
|
||
}
|
||
idMap, err := GetIGDBIDsBySteamIDs(notExistIDs)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
for steamID, igdbID := range idMap {
|
||
res[steamID] = igdbID
|
||
if igdbID != 0 {
|
||
_ = cache.Add(fmt.Sprintf("igdb_id_by_steam_id:%v", steamID), igdbID)
|
||
}
|
||
}
|
||
return res, nil
|
||
} else {
|
||
return GetIGDBIDsBySteamIDs(ids)
|
||
}
|
||
}
|
||
|
||
// GetIGDBPopularGameIDs get IGDB popular game IDs
|
||
// popularity_type = 1 IGDB Visits: Game page visits on IGDB.com.
|
||
// popularity_type = 2 IGDB Want to Play: Additions to IGDB.com users’ “Want to Play” lists.
|
||
// popularity_type = 3 IGDB Playing: Additions to IGDB.com users’ “Playing” lists.
|
||
// popularity_type = 4 IGDB Played: Additions to IGDB.com users’ “Played” lists.
|
||
func GetIGDBPopularGameIDs(popularityType int, offset int, limit int) ([]int, error) {
|
||
var err error
|
||
resp, err := igdbFetch(constant.IGDBPopularityURL, fmt.Sprintf("fields game_id,value,popularity_type; sort value desc; limit %v; offset %v; where popularity_type = %v;", limit, offset, popularityType))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
type IgdbPopularity struct {
|
||
GameID int `json:"game_id"`
|
||
Value float64 `json:"value"`
|
||
}
|
||
var data []IgdbPopularity
|
||
if err = json.Unmarshal(resp.Data, &data); err != nil {
|
||
return nil, err
|
||
}
|
||
ret := make([]int, 0)
|
||
for _, d := range data {
|
||
pid, err := GetIGDBAppParentCache(d.GameID)
|
||
if err != nil {
|
||
ret = append(ret, d.GameID)
|
||
continue
|
||
}
|
||
ret = append(ret, pid)
|
||
}
|
||
return ret, nil
|
||
}
|
||
|
||
func GetIGDBPopularGameIDsCache(popularityType int, offset int, limit int) ([]int, error) {
|
||
if config.Config.RedisAvaliable {
|
||
key := fmt.Sprintf("igdb_popular_game_ids:%v:%v:%v", popularityType, offset, limit)
|
||
val, exist := cache.Get(key)
|
||
if exist {
|
||
var data []int
|
||
if err := json.Unmarshal([]byte(val), &data); err != nil {
|
||
return nil, err
|
||
}
|
||
return data, nil
|
||
} else {
|
||
data, err := GetIGDBPopularGameIDs(popularityType, offset, limit)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
jsonBytes, err := json.Marshal(data)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
_ = cache.AddWithExpire(key, jsonBytes, 12*time.Hour)
|
||
return data, nil
|
||
}
|
||
} else {
|
||
return GetIGDBPopularGameIDs(popularityType, offset, limit)
|
||
}
|
||
}
|