コード例 #1
0
        public override bool Init()
        {
            //Load Music Mods
            _logger.LogInformation("Stage Playlist Mod Path: {StagePlaylistModPath}", _config.Value.Sm5shStagePlaylist.ModFile);

            var stageModJsonFile = _config.Value.Sm5shStagePlaylist.ModFile;
            var generateStageMod = File.Exists(stageModJsonFile);

            if (!generateStageMod)
            {
                _logger.LogDebug("The file {StageModJsonFile} could not be found. The stage playlists will not be updated.", stageModJsonFile);
                return(false);
            }

            var modConfig = JsonConvert.DeserializeObject <List <StagePlaylistModConfig> >(File.ReadAllText(stageModJsonFile));

            foreach (var stagePlaylist in modConfig)
            {
                //Sanitize StageId
                stagePlaylist.StageId = stagePlaylist.StageId.ToLower();
                if (!stagePlaylist.StageId.StartsWith(Constants.InternalIds.STAGE_ID_PREFIX))
                {
                    stagePlaylist.StageId = $"{Constants.InternalIds.STAGE_ID_PREFIX}{stagePlaylist.StageId}";
                }

                //Sanitize Playlist
                stagePlaylist.PlaylistId = stagePlaylist.PlaylistId.ToLower();
                if (!stagePlaylist.PlaylistId.StartsWith(Constants.InternalIds.PLAYLIST_PREFIX))
                {
                    stagePlaylist.PlaylistId = $"{Constants.InternalIds.PLAYLIST_PREFIX}{stagePlaylist.PlaylistId}";
                }

                if (!IdValidationHelper.IsLegalId(stagePlaylist.PlaylistId))
                {
                    _logger.LogError("{StagePlaylistMod} will be disabled. At least one playlist id contains illegal characters.", stageModJsonFile);
                    return(false);
                }

                if (!CoreConstants.VALID_STAGES.Contains(stagePlaylist.StageId))
                {
                    _logger.LogError("{StagePlaylistMod} will be disabled. At least one stage is not registered in the Stage DB.", stageModJsonFile);
                    return(false);
                }

                if (stagePlaylist.OrderId < 0 || stagePlaylist.OrderId > 15)
                {
                    _logger.LogError("{StagePlaylistMod} will be disabled. At least one stage has an invalid order id. The value is 0 to 15.", stageModJsonFile);
                    return(false);
                }
            }

            _modConfig = modConfig.ToDictionary(p => p.StageId, p => p);

            _logger.LogInformation("{StagePlaylistModPath}: Stage Playlist Mod loaded. {NbrPlaylistEntries} entries.", _config.Value.Sm5shStagePlaylist.ModFile, _modConfig.Count);

            return(true);
        }
コード例 #2
0
        private bool ValidateAndSanitizeModConfig()
        {
            //Validate
            if (_musicModConfig.Games == null || _musicModConfig.Games.Count == 0)
            {
                _logger.LogWarning("MusicModFile {MusicMod} is invalid. Skipping...", _musicModConfig.Name);
                return(false);
            }

            //Warning - but no skipping
            if (!string.IsNullOrEmpty(_musicModConfig.Prefix))
            {
                if (_musicModConfig.Prefix.Length > 3)
                {
                    _logger.LogWarning("MusicModFile {MusicMod} {Game} - The prefix seems a little long. It shouldn't be longer than 3 characters.", _musicModConfig.Name);
                }

                //Sanitize
                _musicModConfig.Prefix = _musicModConfig.Prefix.ToLower();
                if (!IdValidationHelper.IsLegalId(_musicModConfig.Prefix))
                {
                    _logger.LogWarning("MusicModFile {MusicMod} - The prefix contains invalid characters. Skipping...", _musicModConfig.Name);
                    return(false);
                }
            }

            var sanitizedGames = new List <Game>();

            foreach (var game in _musicModConfig.Games)
            {
                //Gametitle ID
                if (string.IsNullOrEmpty(game.Id))
                {
                    _logger.LogWarning("MusicModFile {MusicMod} - Game {GameId} is invalid. It does not have a Game Title Id. Skipping...", _musicModConfig.Name, game.Id);
                    continue;
                }
                game.Id = game.Id.ToLower();
                if (!game.Id.StartsWith(Constants.InternalIds.GAME_TITLE_ID_PREFIX))
                {
                    game.Id = $"{Constants.InternalIds.GAME_TITLE_ID_PREFIX}{game.Id}";
                }
                if (!IdValidationHelper.IsLegalId(game.Id))
                {
                    _logger.LogWarning("MusicModFile {MusicMod} - Game {GameId} is invalid. The Game Title Id contains invalid characters. Skipping...", _musicModConfig.Name, game.Id);
                    continue;
                }

                //Series ID
                if (string.IsNullOrEmpty(game.SeriesId))
                {
                    _logger.LogWarning("MusicModFile {MusicMod} - Game {GameId} is invalid. It does not have a Game Series Id. Skipping...", _musicModConfig.Name, game.Id);
                    continue;
                }

                game.SeriesId = game.SeriesId.ToLower();
                if (!game.SeriesId.StartsWith(Constants.InternalIds.GAME_SERIES_ID_PREFIX))
                {
                    game.SeriesId = $"{Constants.InternalIds.GAME_SERIES_ID_PREFIX}{game.SeriesId}";
                }
                if (!CoreConstants.VALID_SERIES.Contains(game.SeriesId))
                {
                    _logger.LogWarning("MusicModFile {MusicMod} - Game {GameId} is invalid. The Game Series Id is invalid. Please check the list of valid Game Series Ids. Skipping...", _musicModConfig.Name, game.Id);
                    _logger.LogDebug("MusicModFile {MusicMod} - Valid Game Series Ids: {GameSeriesIds}", _musicModConfig.Name, string.Join(", ", CoreConstants.VALID_SERIES));
                    continue;
                }

                if (game.Songs == null || game.Songs.Count == 0)
                {
                    _logger.LogWarning("MusicModFile {MusicMod} {Game} is invalid. Skipping...", _musicModConfig.Name, game.Id);
                    continue;
                }

                var sanitizedSongs = new List <Song>();
                foreach (var song in game.Songs)
                {
                    //Filename test
                    if (string.IsNullOrEmpty(song.FileName))
                    {
                        _logger.LogWarning("MusicModFile {MusicMod} {Game} - The song {SongId} doesn't have a filename. Skipping...", _musicModConfig.Name, game.Id, song.Id);
                        continue;
                    }

                    if (!File.Exists(Path.Combine(_musicModPath, song.FileName)))
                    {
                        _logger.LogWarning("MusicModFile {MusicMod} {Game} - Audio file {AudioFile} does not exist. Skipping...", _musicModConfig.Name, game.Id, song.FileName);
                        continue;
                    }

                    //Filename extensions test
                    if (!Constants.VALID_MUSIC_EXTENSIONS.Contains(Path.GetExtension(song.FileName).ToLower()))
                    {
                        _logger.LogWarning("MusicModFile {MusicMod} {Game} - Song {SongId} is invalid. The audio file extension is incompatible. Skipping...", _musicModConfig.Name, game.Id, song.Id);
                        _logger.LogDebug("MusicModFile {MusicMod} {Game} - Valid Extensions: {RecordTypes}", _musicModConfig.Name, game.Id, string.Join(", ", Constants.VALID_MUSIC_EXTENSIONS));
                        continue;
                    }

                    //Song id
                    if (string.IsNullOrEmpty(song?.Id))
                    {
                        _logger.LogWarning("MusicModFile {MusicMod} {Game} - Audio file {AudioFile} is invalid. It does not have a Song Id. Skipping...", _musicModConfig.Name, game.Id, song.FileName);
                        continue;
                    }

                    song.Id = song.Id.ToLower();
                    if (!IdValidationHelper.IsLegalId(song.Id))
                    {
                        _logger.LogWarning("MusicModFile {MusicMod} {Game} - Song {SongId} is invalid. The Song Id contains invalid characters. Skipping...", _musicModConfig.Name, game.Id, song.Id);
                        continue;
                    }

                    //Record type
                    if (!song.RecordType.StartsWith(Constants.InternalIds.RECORD_TYPE_PREFIX))
                    {
                        song.RecordType = $"{Constants.InternalIds.RECORD_TYPE_PREFIX}{song.RecordType}";
                    }
                    if (!Constants.VALID_RECORD_TYPES.Contains(song.RecordType))
                    {
                        _logger.LogWarning("MusicModFile {MusicMod} {Game} - Song {SongId} is invalid. The record type is invalid. Please check the list of valid record types. Skipping...", _musicModConfig.Name, game.Id, song.Id);
                        _logger.LogDebug("MusicModFile {MusicMod} {Game} - Valid Record Types: {RecordTypes}", _musicModConfig.Name, game.Id, string.Join(", ", Constants.VALID_RECORD_TYPES));
                        continue;
                    }

                    //Playlists
                    if (song.Playlists != null)
                    {
                        foreach (var playlist in song.Playlists)
                        {
                            playlist.Id = playlist.Id.ToLower();
                            if (!playlist.Id.StartsWith(Constants.InternalIds.PLAYLIST_PREFIX))
                            {
                                var newPlaylistId = $"{Constants.InternalIds.PLAYLIST_PREFIX}{playlist.Id}";
                                _logger.LogDebug("MusicModFile {MusicMod} {Game} - Song {SongId}'s playlist {Playlist} was renamed {RenamedPlaylist}", _musicModConfig.Name, game.Id, song.Id, playlist.Id, newPlaylistId);
                                playlist.Id = newPlaylistId;
                            }
                        }
                    }

                    sanitizedSongs.Add(song);
                }

                game.Songs = sanitizedSongs;
                sanitizedGames.Add(game);

                if (game.Songs == null || game.Songs.Count == 0)
                {
                    _logger.LogWarning("MusicModFile {MusicMod} {Game} is invalid. Skipping...", game.Id, _musicModConfig.Name);
                    continue;
                }
            }

            _musicModConfig.Games = sanitizedGames;

            //Post song validation warnings
            if (_musicModConfig.Games.Sum(p => p.Songs.Count) == 0)
            {
                _logger.LogWarning("MusicModFile {MusicMod} doesn't contain any valid song. Skipping...", _musicModConfig.Name);
                return(false);
            }

            return(true);
        }