fmartingr
/
games-screenshot-manager
mirror of https://github.com/fmartingr/games-screenshot-manager.git
1
0
Fork 0
Code Issues Releases Wiki Activity

refactor: removed nintendo switch provider 

Nintendo now provides an easy way of getting Switch
screenshots directly to the computer using an USB connection
between the console and the computer.

For more information check: https://en-americas-support.nintendo.com/app/answers/detail/a_id/53664/~/how-to-transfer-screenshots-and-video-captures-to-a-computer-via-a-usb-cable
This commit is contained in:
Felipe M 2022-03-13 20:42:21 +01:00
parent 02f8f05538
commit 9ee5507d1f
Signed by: fmartingr
GPG Key ID: 716BC147715E716F
4 changed files with 0 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
README.md
View File

@ -12,7 +12,6 @@ Use the appropriate ID with the `-provider` flag. [See examples below](#Usage)
| --------------- | ----------------- | ----- | ------- | ----- | ------ | --------------------------------------------------- |
| Steam | `steam` | Yes | Yes | Yes | Yes |
| Minecraft | `minecraft` | Yes | Yes | Yes | No |
| Nintendo Switch | `nintendo-switch` | - | - | - | No | Requires `-input-path` pointing to ALBUM folder |
| PlayStation 4 | `playstation-4` | - | - | - | No | Requires `-input-path` pointing to PS4 folder |
| RetroArch | `retroarch` | - | - | - | Yes | Requires `-input-path` pointing to Playlists folder |

2
internal/cli/cli.go
View File

@ -9,7 +9,6 @@ import (
"github.com/fmartingr/games-screenshot-manager/pkg/cache"
"github.com/fmartingr/games-screenshot-manager/pkg/processor"
"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"
@ -32,7 +31,6 @@ func Start() {
registry := registry.NewProviderRegistry(logger, cache)
registry.Register(minecraft.Name, minecraft.NewMinecraftProvider)
registry.Register(nintendo_switch.Name, nintendo_switch.NewNintendoSwitchProvider)
registry.Register(playstation4.Name, playstation4.NewPlaystation4Provider)
registry.Register(steam.Name, steam.NewSteamProvider)
registry.Register(retroarch.Name, retroarch.NewRetroArchProvider)

68
pkg/providers/nintendo_switch/helpers.go
View File

@ -1,68 +0,0 @@
package nintendo_switch
import (
"encoding/json"
"fmt"
"io/ioutil"
"strings"
"github.com/fmartingr/games-screenshot-manager/internal/models"
"github.com/fmartingr/games-screenshot-manager/pkg/helpers"
)
type SwitchGame struct {
Name string `json:"title_normalized"`
EncryptedGameID string `json:"encrypted_game_id"`
}
func findGameByEncryptedID(gameList []SwitchGame, encryptedGameID string) SwitchGame {
var gameFound SwitchGame = SwitchGame{EncryptedGameID: encryptedGameID}
for _, game := range gameList {
if strings.EqualFold(game.EncryptedGameID, encryptedGameID) {
gameFound = game
}
}
return gameFound
}
func getSwitchGameList() (result []SwitchGame, err error) {
response, err := helpers.DoRequest("GET", gameListURL)
if err != nil {
return nil, fmt.Errorf("error getting switch game list: %s", err)
}
if response.Body != nil {
defer response.Body.Close()
}
body, err := ioutil.ReadAll(response.Body)
if err != nil {
return nil, fmt.Errorf("error getting switch game list: %s", err)
}
jsonErr := json.Unmarshal(body, &result)
if jsonErr != nil {
return nil, fmt.Errorf("error getting switch game list: %s", err)
}
return
}
func addScreenshotToGame(userGames []*models.Game, switchGame SwitchGame, screenshot models.Screenshot) []*models.Game {
var foundGame *models.Game
for gameIndex, game := range userGames {
if game.ID == switchGame.EncryptedGameID {
foundGame = game
userGames[gameIndex].Screenshots = append(userGames[gameIndex].Screenshots, screenshot)
}
}
if foundGame == nil {
foundGame := models.Game{Name: switchGame.Name, ID: switchGame.EncryptedGameID, Platform: platformName, Provider: platformName}
foundGame.Screenshots = append(foundGame.Screenshots, screenshot)
userGames = append(userGames, &foundGame)
}
return userGames
}

64
pkg/providers/nintendo_switch/provider.go
View File

@ -1,64 +0,0 @@
package nintendo_switch
import (
"os"
"path/filepath"
"strings"
"time"
"github.com/fmartingr/games-screenshot-manager/internal/models"
"github.com/sirupsen/logrus"
)
const Name = "nintendo-switch"
const platformName = "Nintendo Switch"
const gameListURL = "https://fmartingr.github.io/switch-games-json/switch_id_names.json"
type NintendoSwitchProvider struct {
logger *logrus.Entry
}
func (p *NintendoSwitchProvider) FindGames(options models.ProviderOptions) ([]*models.Game, error) {
switchGames, err := getSwitchGameList()
if err != nil {
p.logger.Error(err)
return nil, err
}
var userGames []*models.Game
err = filepath.Walk(options.InputPath,
func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if !info.IsDir() {
filename := filepath.Base(path)
extension := filepath.Ext(filepath.Base(path))
filenameParsed := strings.Split(filename[:len(filename)-len(extension)], "-")
switchGame := findGameByEncryptedID(switchGames, filenameParsed[1])
layout := "20060102150405"
destinationName, err := time.Parse(layout, filenameParsed[0][0:14])
if err != nil {
p.logger.Errorf("Could not parse filename '%s': %s", filename, err)
}
screenshot := models.Screenshot{Path: path, DestinationName: destinationName.Format(models.DatetimeFormat) + extension}
userGames = addScreenshotToGame(userGames, switchGame, screenshot)
}
return nil
})
if err != nil {
return nil, err
}
return userGames, nil
}
func NewNintendoSwitchProvider(logger *logrus.Logger, cache models.Cache) models.Provider {
return &NintendoSwitchProvider{
logger: logger.WithField("from", "provider."+Name),
}
}