132 lines
4.6 KiB
Go
132 lines
4.6 KiB
Go
package cli
|
|
|
|
import (
|
|
"bytes"
|
|
"flag"
|
|
"log"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"github.com/fmartingr/games-screenshot-manager/pkg/helpers"
|
|
"github.com/fmartingr/games-screenshot-manager/pkg/providers"
|
|
"github.com/fmartingr/games-screenshot-manager/pkg/providers/minecraft"
|
|
"github.com/fmartingr/games-screenshot-manager/pkg/providers/nintendo_switch"
|
|
"github.com/fmartingr/games-screenshot-manager/pkg/providers/playstation4"
|
|
"github.com/fmartingr/games-screenshot-manager/pkg/providers/retroarch"
|
|
"github.com/fmartingr/games-screenshot-manager/pkg/providers/steam"
|
|
"github.com/gosimple/slug"
|
|
)
|
|
|
|
var allowedProviders = [...]string{"steam", "minecraft", "nintendo-switch", "playstation-4", "retroarch"}
|
|
|
|
const defaultOutputPath string = "./Output"
|
|
|
|
const defaultInputPath string = ""
|
|
const defaultProvider string = "steam"
|
|
const defaultDryRun bool = false
|
|
const defaultDownloadCovers bool = false
|
|
|
|
func Start() {
|
|
cliOptions := providers.ProviderOptions{
|
|
OutputPath: flag.String("output-path", defaultOutputPath, "The destination path of the screenshots"),
|
|
InputPath: flag.String("input-path", defaultInputPath, "Input path for the provider that requires it"),
|
|
DownloadCovers: flag.Bool("download-covers", defaultDownloadCovers, "use to enable the download of covers (if the provider supports it)"),
|
|
DryRun: flag.Bool("dry-run", defaultDryRun, "Use to disable write actions on filesystem"),
|
|
}
|
|
var provider = flag.String("provider", defaultProvider, "steam")
|
|
|
|
flag.Parse()
|
|
|
|
if helpers.SliceContainsString(allowedProviders[:], *provider, nil) {
|
|
games := getGamesFromProvider(*provider, cliOptions)
|
|
processGames(games, cliOptions)
|
|
} else {
|
|
log.Printf("Provider %s not found!", *provider)
|
|
}
|
|
}
|
|
|
|
func getGamesFromProvider(provider string, cliOptions providers.ProviderOptions) []providers.Game {
|
|
var games []providers.Game
|
|
switch provider {
|
|
case "steam":
|
|
games = append(games, steam.GetGames(cliOptions)...)
|
|
case "minecraft":
|
|
games = append(games, minecraft.GetGames(cliOptions)...)
|
|
case "nintendo-switch":
|
|
games = append(games, nintendo_switch.GetGames(cliOptions)...)
|
|
case "playstation-4":
|
|
games = append(games, playstation4.GetGames(cliOptions)...)
|
|
case "retroarch":
|
|
games = append(games, retroarch.GetGames(cliOptions)...)
|
|
}
|
|
return games
|
|
}
|
|
|
|
// TODO: Reduce into smaller functions
|
|
func processGames(games []providers.Game, cliOptions providers.ProviderOptions) {
|
|
for _, game := range games {
|
|
destinationPath := filepath.Join(helpers.ExpandUser(*cliOptions.OutputPath), game.Platform)
|
|
if len(game.Name) > 0 {
|
|
destinationPath = filepath.Join(destinationPath, game.Name)
|
|
} else {
|
|
log.Printf("[IMPORTANT] Game ID %s has no name!", game.ID)
|
|
destinationPath = filepath.Join(destinationPath, game.ID)
|
|
}
|
|
|
|
// Do not continue if there's no screenshots
|
|
if len(game.Screenshots) == 0 {
|
|
continue
|
|
}
|
|
|
|
// Check if folder exists
|
|
if _, err := os.Stat(destinationPath); os.IsNotExist(err) && !*cliOptions.DryRun {
|
|
mkdirErr := os.MkdirAll(destinationPath, 0711)
|
|
if mkdirErr != nil {
|
|
log.Printf("[ERROR] Couldn't create directory with name %s, falling back to %s", game.Name, slug.Make(game.Name))
|
|
destinationPath = filepath.Join(helpers.ExpandUser(*cliOptions.OutputPath), game.Platform, slug.Make(game.Name))
|
|
os.MkdirAll(destinationPath, 0711)
|
|
}
|
|
}
|
|
|
|
if *cliOptions.DownloadCovers && !*cliOptions.DryRun && game.Cover.Path != "" {
|
|
destinationCoverPath := filepath.Join(destinationPath, game.Cover.DestinationName)
|
|
|
|
if _, err := os.Stat(destinationCoverPath); os.IsNotExist(err) {
|
|
helpers.CopyFile(game.Cover.Path, destinationCoverPath)
|
|
}
|
|
}
|
|
|
|
log.Printf("=> Processing screenshots for %s %s", game.Name, game.Notes)
|
|
for _, screenshot := range game.Screenshots {
|
|
destinationPath := filepath.Join(destinationPath, screenshot.GetDestinationName())
|
|
|
|
if _, err := os.Stat(destinationPath); !os.IsNotExist(err) {
|
|
sourceMd5, err := helpers.Md5File(screenshot.Path)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
continue
|
|
}
|
|
destinationMd5, err := helpers.Md5File(destinationPath)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
continue
|
|
}
|
|
|
|
if !bytes.Equal(sourceMd5, destinationMd5) {
|
|
// Images are not equal, we should copy it anyway, but how?
|
|
log.Println("Found different screenshot with equal timestamp for game ", game.Name, screenshot.Path)
|
|
}
|
|
|
|
} else {
|
|
if *cliOptions.DryRun {
|
|
log.Println(filepath.Base(screenshot.Path), " -> ", strings.Replace(destinationPath, helpers.ExpandUser(*cliOptions.OutputPath), "", 1))
|
|
} else {
|
|
helpers.CopyFile(screenshot.Path, destinationPath)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|