pcgamedb/crawler/game.go

package crawler

import (
	"errors"
	"regexp"
	"strings"
	"time"

	"pcgamedb/db"
	"pcgamedb/model"
	"pcgamedb/utils"

	"go.uber.org/zap"

	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
)

func GenerateGameInfo(platform string, id int) (*model.GameInfo, error) {
	switch platform {
	case "steam":
		return GenerateSteamGameInfo(id)
	case "igdb":
		return GenerateIGDBGameInfo(id)
	default:
		return nil, errors.New("invalid ID type")
	}
}

// OrganizeGameItem Organize game item and save game info to database
func OrganizeGameItem(game *model.GameItem) error {
	hasOriganized, _ := db.HasGameItemOrganized(game.ID)
	if hasOriganized {
		return nil
	}

	item, err := OrganizeGameItemWithIGDB(game)
	if err == nil {
		if item.SteamID == 0 {
			// get steam id from igdb
			steamID, err := GetSteamIDByIGDBIDCache(item.IGDBID)
			if err == nil {
				item.SteamID = steamID
			}
		}
		err = db.SaveGameInfo(item)
		if err != nil {
			return err
		}
		return nil
	}
	return err
}

func AddGameInfoManually(gameID primitive.ObjectID, platform string, plateformID int) (*model.GameInfo, error) {
	info, err := GenerateGameInfo(platform, plateformID)
	if err != nil {
		return nil, err
	}
	info.GameIDs = append(info.GameIDs, gameID)
	info.GameIDs = utils.Unique(info.GameIDs)
	return info, db.SaveGameInfo(info)
}

func OrganizeGameItemManually(gameID primitive.ObjectID, platform string, platformID int) (*model.GameInfo, error) {
	info, err := db.GetGameInfoByPlatformID(platform, platformID)
	if err != nil {
		if errors.Is(err, mongo.ErrNoDocuments) {
			info, err = AddGameInfoManually(gameID, platform, platformID)
			if err != nil {
				return nil, err
			}
		} else {
			return nil, err
		}
	}
	info.GameIDs = append(info.GameIDs, gameID)
	info.GameIDs = utils.Unique(info.GameIDs)
	err = db.SaveGameInfo(info)
	if err != nil {
		return nil, err
	}
	if platform == "igdb" {
		steamID, err := GetSteamIDByIGDBIDCache(platformID)
		if err == nil {
			info.SteamID = steamID
		}
	}
	if platform == "steam" {
		igdbID, err := GetIGDBIDBySteamAppIDCache(platformID)
		if err == nil {
			info.IGDBID = igdbID
		}
	}
	return info, nil
}

func FormatName(name string) string {
	name = regexp.MustCompile(`(?i)[\w’'-]+\s(Edition|Vision|Collection|Bundle|Pack|Deluxe)`).ReplaceAllString(name, " ")
	name = regexp.MustCompile(`(?i)GOTY`).ReplaceAllString(name, "")
	name = regexp.MustCompile(`(?i)nsw for pc`).ReplaceAllString(name, "")
	name = regexp.MustCompile(`\([^)]+\)`).ReplaceAllString(name, "")
	name = regexp.MustCompile(`\s+`).ReplaceAllString(name, " ")
	name = strings.Replace(name, ": Remastered", "", -1)
	name = strings.Replace(name, ": Remaster", "", -1)
	name = strings.TrimSpace(name)
	name = strings.Trim(name, ":")
	return name
}

func SupplementPlatformIDToGameInfo(logger *zap.Logger) error {
	infos, err := db.GetAllGameInfos()
	if err != nil {
		return err
	}
	for _, info := range infos {
		changed := false
		if info.IGDBID != 0 && info.SteamID == 0 {
			steamID, err := GetSteamIDByIGDBIDCache(info.IGDBID)
			time.Sleep(time.Millisecond * 100)
			if err != nil {
				continue
			}
			info.SteamID = steamID
			changed = true
		}
		if info.SteamID != 0 && info.IGDBID == 0 {
			igdbID, err := GetIGDBIDBySteamAppIDCache(info.SteamID)
			time.Sleep(time.Millisecond * 100)
			if err != nil {
				continue
			}
			info.IGDBID = igdbID
			changed = true
		}
		if changed {
			logger.Info("supp", zap.String("name", info.Name), zap.Int("igdb", info.IGDBID), zap.Int("steam", info.SteamID))
			_ = db.SaveGameInfo(info)
		} else {
			logger.Info("skip", zap.String("name", info.Name), zap.Int("igdb", info.IGDBID), zap.Int("steam", info.SteamID))
		}
	}
	return nil
}

func UpdateGameInfo(num int) (chan *model.GameInfo, error) {
	infos, err := db.GetOutdatedGameInfos(num)
	if err != nil {
		return nil, err
	}
	updateChan := make(chan *model.GameInfo)

	go func() {
		for _, info := range infos {
			if info.IGDBID != 0 {
				newInfo, err := GenerateIGDBGameInfo(info.IGDBID)
				if err != nil {
					continue
				}
				db.MergeGameInfo(info, newInfo)
				err = db.SaveGameInfo(newInfo)
				if err != nil {
					continue
				}
				updateChan <- newInfo
			}
		}
	}()

	return updateChan, nil
}