070589f718
The migration of the docker container to a rootless one requires the default library to move. This change strips the library path from the path to the ROM and replaces it with an SQL view that concatenates the library path and ROM path.
720 lines
30 KiB
C#
720 lines
30 KiB
C#
using System;
|
|
using System.Data;
|
|
using gaseous_server.Models;
|
|
using IGDB;
|
|
using IGDB.Models;
|
|
|
|
namespace gaseous_server.Classes.Metadata
|
|
{
|
|
public class Games
|
|
{
|
|
const string fieldList = "fields age_ratings,aggregated_rating,aggregated_rating_count,alternative_names,artworks,bundles,category,checksum,collections,cover,created_at,dlcs,expanded_games,expansions,external_games,first_release_date,follows,forks,franchise,franchises,game_engines,game_localizations,game_modes,genres,hypes,involved_companies,keywords,language_supports,multiplayer_modes,name,parent_game,platforms,player_perspectives,ports,rating,rating_count,release_dates,remakes,remasters,screenshots,similar_games,slug,standalone_expansions,status,storyline,summary,tags,themes,total_rating,total_rating_count,updated_at,url,version_parent,version_title,videos,websites;";
|
|
|
|
public Games()
|
|
{
|
|
|
|
}
|
|
|
|
public class InvalidGameId : Exception
|
|
{
|
|
public InvalidGameId(long Id) : base("Unable to find Game by id " + Id)
|
|
{ }
|
|
}
|
|
|
|
public static Game? GetGame(long Id, bool getAllMetadata, bool followSubGames, bool forceRefresh)
|
|
{
|
|
if (Id == 0)
|
|
{
|
|
Game returnValue = new Game();
|
|
if (Storage.GetCacheStatus("Game", 0) == Storage.CacheStatus.NotPresent)
|
|
{
|
|
returnValue = new Game
|
|
{
|
|
Id = 0,
|
|
Name = "Unknown Title",
|
|
Slug = "Unknown"
|
|
};
|
|
Storage.NewCacheValue(returnValue);
|
|
|
|
return returnValue;
|
|
}
|
|
else
|
|
{
|
|
return Storage.GetCacheValue<Game>(returnValue, "id", 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Task<Game> RetVal = _GetGame(SearchUsing.id, Id, getAllMetadata, followSubGames, forceRefresh);
|
|
return RetVal.Result;
|
|
}
|
|
}
|
|
|
|
public static Game GetGame(string Slug, bool getAllMetadata, bool followSubGames, bool forceRefresh)
|
|
{
|
|
Task<Game> RetVal = _GetGame(SearchUsing.slug, Slug, getAllMetadata, followSubGames, forceRefresh);
|
|
return RetVal.Result;
|
|
}
|
|
|
|
public static Game GetGame(DataRow dataRow)
|
|
{
|
|
return Storage.BuildCacheObject<Game>(new Game(), dataRow);
|
|
}
|
|
|
|
private static async Task<Game> _GetGame(SearchUsing searchUsing, object searchValue, bool getAllMetadata = true, bool followSubGames = false, bool forceRefresh = false)
|
|
{
|
|
// check database first
|
|
Storage.CacheStatus? cacheStatus = new Storage.CacheStatus();
|
|
if (searchUsing == SearchUsing.id)
|
|
{
|
|
cacheStatus = Storage.GetCacheStatus("Game", (long)searchValue);
|
|
}
|
|
else
|
|
{
|
|
cacheStatus = Storage.GetCacheStatus("Game", (string)searchValue);
|
|
}
|
|
|
|
if (forceRefresh == true)
|
|
{
|
|
if (cacheStatus == Storage.CacheStatus.Current) { cacheStatus = Storage.CacheStatus.Expired; }
|
|
}
|
|
|
|
string WhereClause = "";
|
|
string searchField = "";
|
|
switch (searchUsing)
|
|
{
|
|
case SearchUsing.id:
|
|
WhereClause = "where id = " + searchValue;
|
|
searchField = "id";
|
|
break;
|
|
case SearchUsing.slug:
|
|
WhereClause = "where slug = \"" + searchValue + "\"";
|
|
searchField = "slug";
|
|
break;
|
|
default:
|
|
throw new Exception("Invalid search type");
|
|
}
|
|
|
|
Game returnValue = new Game();
|
|
switch (cacheStatus)
|
|
{
|
|
case Storage.CacheStatus.NotPresent:
|
|
returnValue = await GetObjectFromServer(WhereClause);
|
|
Storage.NewCacheValue(returnValue);
|
|
UpdateSubClasses(returnValue, getAllMetadata, followSubGames, forceRefresh);
|
|
return returnValue;
|
|
case Storage.CacheStatus.Expired:
|
|
try
|
|
{
|
|
returnValue = await GetObjectFromServer(WhereClause);
|
|
Storage.NewCacheValue(returnValue, true);
|
|
UpdateSubClasses(returnValue, getAllMetadata, followSubGames, forceRefresh);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logging.Log(Logging.LogType.Warning, "Metadata: " + returnValue.GetType().Name, "An error occurred while connecting to IGDB. WhereClause: " + WhereClause, ex);
|
|
returnValue = Storage.GetCacheValue<Game>(returnValue, searchField, searchValue);
|
|
}
|
|
return returnValue;
|
|
case Storage.CacheStatus.Current:
|
|
returnValue = Storage.GetCacheValue<Game>(returnValue, searchField, searchValue);
|
|
UpdateSubClasses(returnValue, false, false, false);
|
|
return returnValue;
|
|
default:
|
|
throw new Exception("How did you get here?");
|
|
}
|
|
}
|
|
|
|
private static void UpdateSubClasses(Game Game, bool getAllMetadata, bool followSubGames, bool forceRefresh)
|
|
{
|
|
// required metadata
|
|
// if (Game.Cover != null)
|
|
// {
|
|
// try
|
|
// {
|
|
// Cover GameCover = Covers.GetCover(Game.Cover.Id, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(Game), forceRefresh);
|
|
// }
|
|
// catch (Exception ex)
|
|
// {
|
|
// Logging.Log(Logging.LogType.Critical, "Game Metadata", "Unable to fetch cover artwork.", ex);
|
|
// }
|
|
// }
|
|
|
|
if (Game.Genres != null)
|
|
{
|
|
foreach (long GenreId in Game.Genres.Ids)
|
|
{
|
|
Genre GameGenre = Genres.GetGenres(GenreId);
|
|
}
|
|
}
|
|
|
|
if (Game.GameModes != null)
|
|
{
|
|
foreach (long gameModeId in Game.GameModes.Ids)
|
|
{
|
|
GameMode gameMode = GameModes.GetGame_Modes(gameModeId);
|
|
}
|
|
}
|
|
|
|
if (Game.MultiplayerModes != null)
|
|
{
|
|
foreach (long multiplayerModeId in Game.MultiplayerModes.Ids)
|
|
{
|
|
MultiplayerMode multiplayerMode = MultiplayerModes.GetGame_MultiplayerModes(multiplayerModeId);
|
|
}
|
|
}
|
|
|
|
if (Game.PlayerPerspectives != null)
|
|
{
|
|
foreach (long PerspectiveId in Game.PlayerPerspectives.Ids)
|
|
{
|
|
PlayerPerspective GamePlayPerspective = PlayerPerspectives.GetGame_PlayerPerspectives(PerspectiveId);
|
|
}
|
|
}
|
|
|
|
if (Game.Themes != null)
|
|
{
|
|
foreach (long ThemeId in Game.Themes.Ids)
|
|
{
|
|
Theme GameTheme = Themes.GetGame_Themes(ThemeId);
|
|
}
|
|
}
|
|
|
|
if (Game.AgeRatings != null)
|
|
{
|
|
foreach (long AgeRatingId in Game.AgeRatings.Ids)
|
|
{
|
|
AgeRating GameAgeRating = AgeRatings.GetAgeRatings(AgeRatingId);
|
|
}
|
|
}
|
|
AgeGroups.GetAgeGroup(Game);
|
|
|
|
if (Game.ReleaseDates != null)
|
|
{
|
|
foreach (long ReleaseDateId in Game.ReleaseDates.Ids)
|
|
{
|
|
ReleaseDate GameReleaseDate = ReleaseDates.GetReleaseDates(ReleaseDateId);
|
|
}
|
|
}
|
|
|
|
// optional metadata - usually downloaded as needed
|
|
if (getAllMetadata == true)
|
|
{
|
|
if (Game.AlternativeNames != null)
|
|
{
|
|
foreach (long AlternativeNameId in Game.AlternativeNames.Ids)
|
|
{
|
|
AlternativeName GameAlternativeName = AlternativeNames.GetAlternativeNames(AlternativeNameId);
|
|
}
|
|
}
|
|
|
|
if (Game.Artworks != null)
|
|
{
|
|
foreach (long ArtworkId in Game.Artworks.Ids)
|
|
{
|
|
try
|
|
{
|
|
Artwork GameArtwork = Artworks.GetArtwork(ArtworkId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(Game), forceRefresh);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logging.Log(Logging.LogType.Critical, "Game Metadata", "Unable to fetch artwork id: " + ArtworkId, ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (followSubGames)
|
|
{
|
|
List<long> gamesToFetch = new List<long>();
|
|
if (Game.Bundles != null) { gamesToFetch.AddRange(Game.Bundles.Ids); }
|
|
if (Game.Dlcs != null) { gamesToFetch.AddRange(Game.Dlcs.Ids); }
|
|
if (Game.Expansions != null) { gamesToFetch.AddRange(Game.Expansions.Ids); }
|
|
if (Game.ParentGame != null) { gamesToFetch.Add((long)Game.ParentGame.Id); }
|
|
//if (Game.SimilarGames != null) { gamesToFetch.AddRange(Game.SimilarGames.Ids); }
|
|
if (Game.StandaloneExpansions != null) { gamesToFetch.AddRange(Game.StandaloneExpansions.Ids); }
|
|
if (Game.VersionParent != null) { gamesToFetch.Add((long)Game.VersionParent.Id); }
|
|
|
|
foreach (long gameId in gamesToFetch)
|
|
{
|
|
Game relatedGame = GetGame(gameId, false, true, false);
|
|
}
|
|
}
|
|
|
|
if (Game.Collection != null)
|
|
{
|
|
Collection GameCollection = Collections.GetCollections(Game.Collection.Id);
|
|
}
|
|
|
|
if (Game.ExternalGames != null)
|
|
{
|
|
foreach (long ExternalGameId in Game.ExternalGames.Ids)
|
|
{
|
|
ExternalGame GameExternalGame = ExternalGames.GetExternalGames(ExternalGameId);
|
|
}
|
|
}
|
|
|
|
if (Game.Franchise != null)
|
|
{
|
|
Franchise GameFranchise = Franchises.GetFranchises(Game.Franchise.Id);
|
|
}
|
|
|
|
if (Game.Franchises != null)
|
|
{
|
|
foreach (long FranchiseId in Game.Franchises.Ids)
|
|
{
|
|
Franchise GameFranchise = Franchises.GetFranchises(FranchiseId);
|
|
}
|
|
}
|
|
|
|
if (Game.InvolvedCompanies != null)
|
|
{
|
|
foreach (long involvedCompanyId in Game.InvolvedCompanies.Ids)
|
|
{
|
|
InvolvedCompany involvedCompany = InvolvedCompanies.GetInvolvedCompanies(involvedCompanyId);
|
|
}
|
|
}
|
|
|
|
if (Game.Platforms != null)
|
|
{
|
|
foreach (long PlatformId in Game.Platforms.Ids)
|
|
{
|
|
Platform GamePlatform = Platforms.GetPlatform(PlatformId);
|
|
}
|
|
}
|
|
|
|
if (Game.Screenshots != null)
|
|
{
|
|
foreach (long ScreenshotId in Game.Screenshots.Ids)
|
|
{
|
|
try
|
|
{
|
|
Screenshot GameScreenshot = Screenshots.GetScreenshot(ScreenshotId, Config.LibraryConfiguration.LibraryMetadataDirectory_Game(Game), forceRefresh);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Logging.Log(Logging.LogType.Critical, "Game Metadata", "Unable to fetch screenshot id: " + ScreenshotId, ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Game.Videos != null)
|
|
{
|
|
foreach (long GameVideoId in Game.Videos.Ids)
|
|
{
|
|
GameVideo gameVideo = GamesVideos.GetGame_Videos(GameVideoId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private enum SearchUsing
|
|
{
|
|
id,
|
|
slug
|
|
}
|
|
|
|
private static async Task<Game> GetObjectFromServer(string WhereClause)
|
|
{
|
|
// get Game metadata
|
|
Communications comms = new Communications();
|
|
var results = await comms.APIComm<Game>(IGDBClient.Endpoints.Games, fieldList, WhereClause);
|
|
var result = results.First();
|
|
|
|
// add artificial unknown platform mapping
|
|
List<long> platformIds = new List<long>();
|
|
platformIds.Add(0);
|
|
if (result.Platforms != null)
|
|
{
|
|
if (result.Platforms.Ids != null)
|
|
{
|
|
platformIds.AddRange(result.Platforms.Ids.ToList());
|
|
}
|
|
}
|
|
result.Platforms = new IdentitiesOrValues<Platform>(
|
|
ids: platformIds.ToArray<long>()
|
|
);
|
|
|
|
// get cover art from parent if this has no cover
|
|
if (result.Cover == null)
|
|
{
|
|
if (result.ParentGame != null)
|
|
{
|
|
if (result.ParentGame.Id != null)
|
|
{
|
|
Logging.Log(Logging.LogType.Information, "Game Metadata", "Game has no cover art, fetching cover art from parent game");
|
|
Game parentGame = GetGame((long)result.ParentGame.Id, false, false, false);
|
|
result.Cover = parentGame.Cover;
|
|
}
|
|
}
|
|
}
|
|
|
|
// get missing metadata from parent if this is a port
|
|
if (result.Category == Category.Port)
|
|
{
|
|
if (result.Summary == null)
|
|
{
|
|
if (result.ParentGame != null)
|
|
{
|
|
if (result.ParentGame.Id != null)
|
|
{
|
|
Logging.Log(Logging.LogType.Information, "Game Metadata", "Game has no summary, fetching summary from parent game");
|
|
Game parentGame = GetGame((long)result.ParentGame.Id, false, false, false);
|
|
result.Summary = parentGame.Summary;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static void AssignAllGamesToPlatformIdZero()
|
|
{
|
|
Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
|
|
string sql = "SELECT * FROM Game;";
|
|
DataTable gamesTable = db.ExecuteCMD(sql);
|
|
foreach (DataRow gameRow in gamesTable.Rows)
|
|
{
|
|
sql = "DELETE FROM Relation_Game_Platforms WHERE PlatformsId = 0 AND GameId = @Id; INSERT INTO Relation_Game_Platforms (GameId, PlatformsId) VALUES (@Id, 0);";
|
|
Dictionary<string, object> dbDict = new Dictionary<string, object>();
|
|
dbDict.Add("Id", (long)gameRow["Id"]);
|
|
db.ExecuteCMD(sql, dbDict);
|
|
}
|
|
}
|
|
|
|
private static bool AllowNoPlatformSearch = false;
|
|
|
|
public static Game[] SearchForGame(string SearchString, long PlatformId, SearchType searchType)
|
|
{
|
|
// search local first
|
|
Logging.Log(Logging.LogType.Information, "Game Search", "Attempting local search of type '" + searchType.ToString() + "' for " + SearchString);
|
|
Task<Game[]> games = _SearchForGameDatabase(SearchString, PlatformId, searchType);
|
|
if (games.Result.Length == 0)
|
|
{
|
|
// fall back to online search
|
|
Logging.Log(Logging.LogType.Information, "Game Search", "Falling back to remote search of type '" + searchType.ToString() + "' for " + SearchString);
|
|
games = _SearchForGameRemote(SearchString, PlatformId, searchType);
|
|
}
|
|
return games.Result;
|
|
}
|
|
|
|
private static async Task<Game[]> _SearchForGameDatabase(string SearchString, long PlatformId, SearchType searchType)
|
|
{
|
|
string whereClause = "";
|
|
Dictionary<string, object> dbDict = new Dictionary<string, object>();
|
|
|
|
bool allowSearch = true;
|
|
switch (searchType)
|
|
{
|
|
case SearchType.searchNoPlatform:
|
|
whereClause = "MATCH(`Name`) AGAINST (@gamename)";
|
|
dbDict.Add("platformid", PlatformId);
|
|
dbDict.Add("gamename", SearchString);
|
|
|
|
allowSearch = AllowNoPlatformSearch;
|
|
break;
|
|
case SearchType.search:
|
|
whereClause = "PlatformsId = @platformid AND MATCH(`Name`) AGAINST (@gamename)";
|
|
dbDict.Add("platformid", PlatformId);
|
|
dbDict.Add("gamename", SearchString);
|
|
break;
|
|
case SearchType.wherefuzzy:
|
|
whereClause = "PlatformsId = @platformid AND `Name` LIKE @gamename";
|
|
dbDict.Add("platformid", PlatformId);
|
|
dbDict.Add("gamename", "%" + SearchString + "%");
|
|
break;
|
|
case SearchType.where:
|
|
whereClause = "PlatformsId = @platformid AND `Name` = @gamename";
|
|
dbDict.Add("platformid", PlatformId);
|
|
dbDict.Add("gamename", SearchString);
|
|
break;
|
|
}
|
|
|
|
string sql = "SELECT Game.Id, Game.`Name`, Game.Slug, Relation_Game_Platforms.PlatformsId AS PlatformsId, Game.Summary FROM gaseous.Game JOIN Relation_Game_Platforms ON Game.Id = Relation_Game_Platforms.GameId WHERE " + whereClause + ";";
|
|
|
|
|
|
// get Game metadata
|
|
Game[]? results = new Game[0];
|
|
if (allowSearch == true)
|
|
{
|
|
List<Game> searchResults = new List<Game>();
|
|
Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
|
|
DataTable data = db.ExecuteCMD(sql, dbDict);
|
|
foreach (DataRow row in data.Rows)
|
|
{
|
|
Game game = new Game
|
|
{
|
|
Id = (long)row["Id"],
|
|
Name = (string)Common.ReturnValueIfNull(row["Name"], ""),
|
|
Slug = (string)Common.ReturnValueIfNull(row["Slug"], ""),
|
|
Summary = (string)Common.ReturnValueIfNull(row["Summary"], "")
|
|
};
|
|
searchResults.Add(game);
|
|
}
|
|
|
|
results = searchResults.ToArray();
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
private static async Task<Game[]> _SearchForGameRemote(string SearchString, long PlatformId, SearchType searchType)
|
|
{
|
|
string searchBody = "";
|
|
string searchFields = "fields id,name,slug,platforms,summary; ";
|
|
bool allowSearch = true;
|
|
switch (searchType)
|
|
{
|
|
case SearchType.searchNoPlatform:
|
|
searchBody = "search \"" + SearchString + "\"; ";
|
|
|
|
allowSearch = AllowNoPlatformSearch;
|
|
break;
|
|
case SearchType.search:
|
|
searchBody = "search \"" + SearchString + "\"; where platforms = (" + PlatformId + ");";
|
|
break;
|
|
case SearchType.wherefuzzy:
|
|
searchBody = "where platforms = (" + PlatformId + ") & name ~ *\"" + SearchString + "\"*;";
|
|
break;
|
|
case SearchType.where:
|
|
searchBody = "where platforms = (" + PlatformId + ") & name ~ \"" + SearchString + "\";";
|
|
break;
|
|
}
|
|
|
|
// check search cache
|
|
Game[]? games = Communications.GetSearchCache<Game[]?>(searchFields, searchBody);
|
|
|
|
if (games == null)
|
|
{
|
|
// cache miss
|
|
// get Game metadata
|
|
Communications comms = new Communications();
|
|
Game[]? results = new Game[0];
|
|
if (allowSearch == true)
|
|
{
|
|
results = await comms.APIComm<Game>(IGDBClient.Endpoints.Games, searchFields, searchBody);
|
|
|
|
Communications.SetSearchCache<Game[]?>(searchFields, searchBody, results);
|
|
}
|
|
|
|
return results;
|
|
}
|
|
else
|
|
{
|
|
return games.ToArray();
|
|
}
|
|
}
|
|
|
|
public static List<AvailablePlatformItem> GetAvailablePlatforms(string UserId, long GameId)
|
|
{
|
|
Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
|
|
string sql = @"
|
|
SELECT DISTINCT
|
|
view_Games_Roms.GameId,
|
|
view_Games_Roms.PlatformId,
|
|
Platform.`Name`,
|
|
User_RecentPlayedRoms.UserId AS MostRecentUserId,
|
|
User_RecentPlayedRoms.RomId AS MostRecentRomId,
|
|
CASE User_RecentPlayedRoms.IsMediaGroup
|
|
WHEN 0 THEN GMR.`Name`
|
|
WHEN 1 THEN 'Media Group'
|
|
ELSE NULL
|
|
END AS `MostRecentRomName`,
|
|
User_RecentPlayedRoms.IsMediaGroup AS MostRecentRomIsMediaGroup,
|
|
User_GameFavouriteRoms.UserId AS FavouriteUserId,
|
|
User_GameFavouriteRoms.RomId AS FavouriteRomId,
|
|
CASE User_GameFavouriteRoms.IsMediaGroup
|
|
WHEN 0 THEN GFV.`Name`
|
|
WHEN 1 THEN 'Media Group'
|
|
ELSE NULL
|
|
END AS `FavouriteRomName`,
|
|
User_GameFavouriteRoms.IsMediaGroup AS FavouriteRomIsMediaGroup
|
|
FROM
|
|
view_Games_Roms
|
|
LEFT JOIN
|
|
Platform ON view_Games_Roms.PlatformId = Platform.Id
|
|
LEFT JOIN
|
|
User_RecentPlayedRoms ON User_RecentPlayedRoms.UserId = @userid
|
|
AND User_RecentPlayedRoms.GameId = view_Games_Roms.GameId
|
|
AND User_RecentPlayedRoms.PlatformId = view_Games_Roms.PlatformId
|
|
LEFT JOIN
|
|
User_GameFavouriteRoms ON User_GameFavouriteRoms.UserId = @userid
|
|
AND User_GameFavouriteRoms.GameId = view_Games_Roms.GameId
|
|
AND User_GameFavouriteRoms.PlatformId = view_Games_Roms.PlatformId
|
|
LEFT JOIN
|
|
view_Games_Roms AS GMR ON GMR.Id = User_RecentPlayedRoms.RomId
|
|
LEFT JOIN
|
|
view_Games_Roms AS GFV ON GFV.Id = User_GameFavouriteRoms.RomId
|
|
WHERE
|
|
view_Games_Roms.GameId = @gameid
|
|
ORDER BY Platform.`Name`;";
|
|
Dictionary<string, object> dbDict = new Dictionary<string, object>
|
|
{
|
|
{ "gameid", GameId },
|
|
{ "userid", UserId }
|
|
};
|
|
DataTable data = db.ExecuteCMD(sql, dbDict);
|
|
|
|
PlatformMapping platformMapping = new PlatformMapping();
|
|
List<AvailablePlatformItem> platforms = new List<AvailablePlatformItem>();
|
|
foreach (DataRow row in data.Rows)
|
|
{
|
|
IGDB.Models.Platform platform = Platforms.GetPlatform((long)row["PlatformId"]);
|
|
PlatformMapping.UserEmulatorConfiguration? emulatorConfiguration = platformMapping.GetUserEmulator(UserId, GameId, (long)platform.Id);
|
|
|
|
if (emulatorConfiguration == null)
|
|
{
|
|
if (platform.Id != 0)
|
|
{
|
|
Models.PlatformMapping.PlatformMapItem platformMap = PlatformMapping.GetPlatformMap((long)platform.Id);
|
|
emulatorConfiguration = new PlatformMapping.UserEmulatorConfiguration
|
|
{
|
|
EmulatorType = platformMap.WebEmulator.Type,
|
|
Core = platformMap.WebEmulator.Core,
|
|
EnableBIOSFiles = platformMap.EnabledBIOSHashes
|
|
};
|
|
}
|
|
}
|
|
|
|
long? LastPlayedRomId = null;
|
|
bool? LastPlayedIsMediagroup = false;
|
|
string? LastPlayedRomName = null;
|
|
if (row["MostRecentRomId"] != DBNull.Value)
|
|
{
|
|
LastPlayedRomId = (long?)row["MostRecentRomId"];
|
|
LastPlayedIsMediagroup = (bool)row["MostRecentRomIsMediaGroup"];
|
|
if (row["MostRecentRomName"] != System.DBNull.Value)
|
|
{
|
|
LastPlayedRomName = string.IsNullOrEmpty((string?)row["MostRecentRomName"]) ? "" : (string)row["MostRecentRomName"];
|
|
}
|
|
}
|
|
|
|
long? FavouriteRomId = null;
|
|
bool? FavouriteRomIsMediagroup = false;
|
|
string? FavouriteRomName = null;
|
|
if (row["FavouriteRomId"] != DBNull.Value)
|
|
{
|
|
FavouriteRomId = (long?)row["FavouriteRomId"];
|
|
FavouriteRomIsMediagroup = (bool)row["FavouriteRomIsMediaGroup"];
|
|
if (row["MostRecentRomName"] != System.DBNull.Value)
|
|
{
|
|
FavouriteRomName = string.IsNullOrEmpty((string?)row["MostRecentRomName"]) ? "" : (string)row["MostRecentRomName"];
|
|
}
|
|
}
|
|
|
|
AvailablePlatformItem valuePair = new AvailablePlatformItem
|
|
{
|
|
Id = platform.Id,
|
|
Name = platform.Name,
|
|
Category = platform.Category,
|
|
emulatorConfiguration = emulatorConfiguration,
|
|
LastPlayedRomId = LastPlayedRomId,
|
|
LastPlayedRomIsMediagroup = LastPlayedIsMediagroup,
|
|
LastPlayedRomName = LastPlayedRomName,
|
|
FavouriteRomId = FavouriteRomId,
|
|
FavouriteRomIsMediagroup = FavouriteRomIsMediagroup,
|
|
FavouriteRomName = FavouriteRomName
|
|
};
|
|
platforms.Add(valuePair);
|
|
}
|
|
|
|
return platforms;
|
|
}
|
|
|
|
public static void GameSetFavouriteRom(string UserId, long GameId, long PlatformId, long RomId, bool IsMediaGroup)
|
|
{
|
|
Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
|
|
string sql = "DELETE FROM User_GameFavouriteRoms WHERE UserId = @userid AND GameId = @gameid AND PlatformId = @platformid; INSERT INTO User_GameFavouriteRoms (UserId, GameId, PlatformId, RomId, IsMediaGroup) VALUES (@userid, @gameid, @platformid, @romid, @ismediagroup);";
|
|
Dictionary<string, object> dbDict = new Dictionary<string, object>
|
|
{
|
|
{ "userid", UserId },
|
|
{ "gameid", GameId },
|
|
{ "platformid", PlatformId },
|
|
{ "romid", RomId },
|
|
{ "ismediagroup", IsMediaGroup }
|
|
};
|
|
db.ExecuteCMD(sql, dbDict);
|
|
}
|
|
|
|
public static void GameClearFavouriteRom(string UserId, long GameId, long PlatformId)
|
|
{
|
|
Database db = new Database(Database.databaseType.MySql, Config.DatabaseConfiguration.ConnectionString);
|
|
string sql = "DELETE FROM User_GameFavouriteRoms WHERE UserId = @userid AND GameId = @gameid AND PlatformId = @platformid;";
|
|
Dictionary<string, object> dbDict = new Dictionary<string, object>
|
|
{
|
|
{ "userid", UserId },
|
|
{ "gameid", GameId },
|
|
{ "platformid", PlatformId }
|
|
};
|
|
db.ExecuteCMD(sql, dbDict);
|
|
}
|
|
|
|
public class AvailablePlatformItem : IGDB.Models.Platform
|
|
{
|
|
public PlatformMapping.UserEmulatorConfiguration emulatorConfiguration { get; set; }
|
|
public long? LastPlayedRomId { get; set; }
|
|
public bool? LastPlayedRomIsMediagroup { get; set; }
|
|
public string? LastPlayedRomName { get; set; }
|
|
public long? FavouriteRomId { get; set; }
|
|
public bool? FavouriteRomIsMediagroup { get; set; }
|
|
public string? FavouriteRomName { get; set; }
|
|
}
|
|
|
|
public enum SearchType
|
|
{
|
|
where = 0,
|
|
wherefuzzy = 1,
|
|
search = 2,
|
|
searchNoPlatform = 3
|
|
}
|
|
|
|
public class MinimalGameItem
|
|
{
|
|
public MinimalGameItem()
|
|
{
|
|
|
|
}
|
|
|
|
public MinimalGameItem(Game gameObject)
|
|
{
|
|
this.Id = gameObject.Id;
|
|
this.Name = gameObject.Name;
|
|
this.Slug = gameObject.Slug;
|
|
this.Summary = gameObject.Summary;
|
|
this.TotalRating = gameObject.TotalRating;
|
|
this.TotalRatingCount = gameObject.TotalRatingCount;
|
|
this.Cover = gameObject.Cover;
|
|
this.Artworks = gameObject.Artworks;
|
|
this.FirstReleaseDate = gameObject.FirstReleaseDate;
|
|
|
|
// compile age ratings
|
|
this.AgeRatings = new List<AgeRating>();
|
|
if (gameObject.AgeRatings != null)
|
|
{
|
|
foreach (long ageRatingId in gameObject.AgeRatings.Ids)
|
|
{
|
|
AgeRating? rating = Classes.Metadata.AgeRatings.GetAgeRatings(ageRatingId);
|
|
if (rating != null)
|
|
{
|
|
this.AgeRatings.Add(rating);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public long? Id { get; set; }
|
|
public long Index { get; set; }
|
|
public string Name { get; set; }
|
|
public string Slug { get; set; }
|
|
public string Summary { get; set; }
|
|
public double? TotalRating { get; set; }
|
|
public int? TotalRatingCount { get; set; }
|
|
public bool HasSavedGame { get; set; } = false;
|
|
public bool IsFavourite { get; set; } = false;
|
|
public DateTimeOffset? FirstReleaseDate { get; set; }
|
|
public IGDB.IdentityOrValue<IGDB.Models.Cover> Cover { get; set; }
|
|
public IGDB.IdentitiesOrValues<IGDB.Models.Artwork> Artworks { get; set; }
|
|
public List<IGDB.Models.AgeRating> AgeRatings { get; set; }
|
|
}
|
|
}
|
|
} |