// Add code to be executed when game is preparing to be started.
public override void OnGameStopped(Game game, long elapsedSeconds)
{
try
{
var TaskIntegrationUI = Task.Run(() =>
{
DispatcherOperation dispatcherOp = null;
if (PlayniteApi.ApplicationInfo.Mode == ApplicationMode.Desktop)
{
dispatcherOp = howLongToBeatUI.AddElements();
}
else if (PlayniteApi.ApplicationInfo.Mode == ApplicationMode.Fullscreen)
{
dispatcherOp = howLongToBeatUI.AddElementsFS();
}
if (dispatcherOp != null)
{
dispatcherOp.Completed += (s, e) => { howLongToBeatUI.RefreshElements(HowLongToBeatDatabase.GameSelected); };
}
});
}
catch (Exception ex)
{
Common.LogError(ex, "HowLongToBeat");
}
// AutoSetCurrentPlayTime
if (settings.AutoSetCurrentPlayTime)
{
try
{
/*
* Task.Run(() =>
* {
* PluginDatabase.SetCurrentPlayTime(game, elapsedSeconds);
* });
*/
var result = PlayniteApi.Dialogs.ShowMessage(resources.GetString("LOCHowLongToBeatSetCurrentTime"), "HowLongToBeat", MessageBoxButton.YesNo);
if (result == MessageBoxResult.Yes)
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
$"HowLongToBeat - {resources.GetString("LOCCommonProcessing")}",
false
);
globalProgressOptions.IsIndeterminate = true;
PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
PluginDatabase.SetCurrentPlayTime(game, elapsedSeconds);
}, globalProgressOptions);
}
}
catch (Exception ex)
{
Common.LogError(ex, "HowLongToBeat");
}
}
}
public void RefreshData(Game game)
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
$"{PluginName} - {resources.GetString("LOCCommonRefreshGameData")}",
false
);
globalProgressOptions.IsIndeterminate = true;
PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
try
{
GameSettings gameSettings = GetGameSettings(game.Id);
if (gameSettings != null)
{
SetDataFromSettings(gameSettings);
}
}
catch (Exception ex)
{
Common.LogError(ex, false, true, PluginName);
}
}, globalProgressOptions);
}
public void RefreshUserData()
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
$"{PluginName} - {resources.GetString("LOCHowLongToBeatPluginGetUserView")}",
false
);
globalProgressOptions.IsIndeterminate = true;
_PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
HltbUserStats UserHltbData = howLongToBeatClient.GetUserData();
if (UserHltbData != null)
{
try
{
string PathHltbUserStats = Path.Combine(PluginUserDataPath, "HltbUserStats.json");
File.WriteAllText(PathHltbUserStats, JsonConvert.SerializeObject(UserHltbData));
}
catch (Exception ex)
{
Common.LogError(ex, "HowLongToBeat");
}
Database.UserHltbData = UserHltbData;
}
}, globalProgressOptions);
}
private void PART_BtAddSteamGridDb_Click(object sender, RoutedEventArgs e)
{
try
{
SteamGridDbType steamGridDbType = SteamGridDbType.heroes;
if (_IsCover)
{
steamGridDbType = SteamGridDbType.grids;
}
var ViewExtension = new SteamGridDbView(_gameBackgroundImages.Name, steamGridDbType);
Window windowExtension = PlayniteUiHelper.CreateExtensionWindow(PluginDatabase.PlayniteApi, "SteamGridDB", ViewExtension);
windowExtension.ShowDialog();
if (ViewExtension.steamGridDbResult != null)
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
resources.GetString("LOCCommonGettingData"),
false
);
globalProgressOptions.IsIndeterminate = true;
var ProgressDownload = PluginDatabase.PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
try
{
var cachedFile = HttpFileCache.GetWebFile(ViewExtension.steamGridDbResult.url);
_backgroundImagesEdited.Add(new ItemImage
{
Name = cachedFile
});
}
catch (Exception ex)
{
Common.LogError(ex, false, true, "BackgroundChanger");
}
}, globalProgressOptions);
Task.Run(() =>
{
while (!(bool)ProgressDownload.Result)
{
}
}).ContinueWith(antecedant =>
{
this.Dispatcher.BeginInvoke((Action) delegate
{
PART_LbBackgroundImages.ItemsSource = null;
PART_LbBackgroundImages.ItemsSource = _backgroundImagesEdited;
});
});
}
}
catch (Exception ex)
{
Common.LogError(ex, false, true, "BackgroundChanger");
}
}
public void ConvertDB(IPlayniteAPI PlayniteApi)
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
"SystemChecker - Database migration",
false
);
globalProgressOptions.IsIndeterminate = true;
PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
logger.Info($"SystemChecker - ConvertDB()");
int Converted = 0;
foreach (var item in Items)
{
try
{
if (PlayniteApi.Database.Games.Get(item.Key) != null)
{
GameRequierements gameRequierements = SystemChecker.PluginDatabase.Get(item.Key, true);
Requirement Minimum = item.Value.Minimum;
Minimum.IsMinimum = true;
Requirement Recommanded = item.Value.Recommanded;
gameRequierements.Items = new List <Requirement> {
Minimum, Recommanded
};
Thread.Sleep(10);
SystemChecker.PluginDatabase.Update(gameRequierements);
Converted++;
}
else
{
logger.Warn($"SystemChecker - Game is deleted - {item.Key.ToString()}");
}
}
catch (Exception ex)
{
Common.LogError(ex, "SystemChecker", $"Failed to load ConvertDB from {item.Key.ToString()}");
}
}
logger.Info($"SystemChecker - Converted {Converted} / {Items.Count}");
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
logger.Info($"SystemChecker - Migration - {String.Format("{0:00}:{1:00}.{2:00}", ts.Minutes, ts.Seconds, ts.Milliseconds / 10)}");
}, globalProgressOptions);
IsOld = false;
}
public void ConvertDB(IPlayniteAPI PlayniteApi)
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
"SuccessStory - Database migration",
false
);
globalProgressOptions.IsIndeterminate = true;
PlayniteApi.Dialogs.ActivateGlobalProgress((Action <GlobalProgressActionArgs>)((activateGlobalProgress) =>
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
logger.Info($"SuccessStory - ConvertDB()");
int Converted = 0;
foreach (var item in Items)
{
try
{
if (PlayniteApi.Database.Games.Get(item.Key) != null)
{
GameAchievements gameAchievements = SuccessStory.PluginDatabase.Get(item.Key, true);
gameAchievements.HaveAchivements = item.Value.HaveAchivements;
gameAchievements.IsEmulators = item.Value.IsEmulators;
gameAchievements.Total = item.Value.Total;
gameAchievements.Unlocked = item.Value.Unlocked;
gameAchievements.Locked = item.Value.Locked;
gameAchievements.Progression = item.Value.Progression;
gameAchievements.Items = item.Value.Achievements;
Thread.Sleep(10);
SuccessStory.PluginDatabase.Update(gameAchievements);
Converted++;
}
else
{
logger.Warn($"SuccessStory - Game is deleted - {item.Key.ToString()}");
}
}
catch (Exception ex)
{
Common.LogError(ex, "SuccessStory", $"Failed to load ConvertDB from {item.Key.ToString()}");
}
}
logger.Info($"SuccessStory - Converted {Converted} / {Items.Count}");
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
logger.Info($"SuccessStory - Migration - {string.Format("{0:00}:{1:00}.{2:00}", ts.Minutes, ts.Seconds, ts.Milliseconds / 10)}");
}), globalProgressOptions);
IsOld = false;
}
public override void OnLibraryUpdated(OnLibraryUpdatedEventArgs args)
{
// This needs to be done in this event because the ItemCollectionChanged raises the event
// immediately when a game is added to the database, which means the games may not have
// the necessary metadata added to download the assets automatically
if (settings.Settings.DownloadLogosOnLibUpdate == true)
{
var progressOptions = new GlobalProgressOptions(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageLibUpdateAutomaticDownload"), true);
progressOptions.IsIndeterminate = false;
PlayniteApi.Dialogs.ActivateGlobalProgress((a) =>
{
var games = PlayniteApi.Database.Games.Where(x => x.Added != null && x.Added > settings.Settings.LastAutoLibUpdateAssetsDownload);
a.ProgressMaxValue = games.Count();
foreach (var game in games)
{
if (a.CancelToken.IsCancellationRequested)
{
break;
}
if (!logosDownloader.DownloadSteamLogo(game, false, settings.Settings.LibUpdateSelectLogosAutomatically))
{
logosDownloader.DownloadSgdbLogo(game, false, settings.Settings.LibUpdateSelectLogosAutomatically);
}
a.CurrentProgressValue++;
}
;
}, progressOptions);
}
if ((settings.Settings.DownloadVideosOnLibUpdate || settings.Settings.DownloadVideosMicroOnLibUpdate) && ValidateExecutablesSettings(true, false))
{
var progressOptions = new GlobalProgressOptions(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageLibUpdateAutomaticDownloadVideos"), true);
progressOptions.IsIndeterminate = false;
PlayniteApi.Dialogs.ActivateGlobalProgress((a) =>
{
var games = PlayniteApi.Database.Games.Where(x => x.Added != null && x.Added > settings.Settings.LastAutoLibUpdateAssetsDownload);
a.ProgressMaxValue = games.Count();
foreach (var game in games)
{
if (a.CancelToken.IsCancellationRequested)
{
break;
}
videosDownloader.DownloadSteamVideo(game, false, true, settings.Settings.DownloadVideosOnLibUpdate, settings.Settings.DownloadVideosMicroOnLibUpdate);
a.CurrentProgressValue++;
}
;
}, progressOptions);
}
settings.Settings.LastAutoLibUpdateAssetsDownload = DateTime.Now;
SavePluginSettings(settings.Settings);
UpdateAssetsTagsStatus();
}
public void RemoveTagAllGame(bool FromClearDatabase = false)
{
#if DEBUG
logger.Debug($"{PluginName} - RemoveTagAllGame");
#endif
string Message = string.Empty;
if (FromClearDatabase)
{
Message = $"{PluginName} - {resources.GetString("LOCCommonClearingAllTag")}";
}
else
{
Message = $"{PluginName} - {resources.GetString("LOCCommonRemovingAllTag")}";
}
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(Message, true);
globalProgressOptions.IsIndeterminate = false;
_PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
try
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
var PlayniteDb = _PlayniteApi.Database.Games.Where(x => x.Hidden == false);
activateGlobalProgress.ProgressMaxValue = (double)PlayniteDb.Count();
string CancelText = string.Empty;
foreach (Game game in PlayniteDb)
{
if (activateGlobalProgress.CancelToken.IsCancellationRequested)
{
CancelText = " canceled";
break;
}
RemoveTag(game);
activateGlobalProgress.CurrentProgressValue++;
}
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
logger.Info($"{PluginName} - RemoveTagAllGame(){CancelText} - {string.Format("{0:00}:{1:00}.{2:00}", ts.Minutes, ts.Seconds, ts.Milliseconds / 10)} for {activateGlobalProgress.CurrentProgressValue}/{(double)PlayniteDb.Count()} items");
}
catch (Exception ex)
{
Common.LogError(ex, PluginName);
}
}, globalProgressOptions);
}
private void PART_BtAbsolute_Click(object sender, RoutedEventArgs e)
{
TextboxSearch.Text = string.Empty;
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
PluginDatabase.PluginName,
true
);
globalProgressOptions.IsIndeterminate = false;
PluginDatabase.PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
try
{
activateGlobalProgress.ProgressMaxValue = listGameScreenshots.Count;
foreach (var game in listGameScreenshots)
{
if (activateGlobalProgress.CancelToken.IsCancellationRequested)
{
break;
}
foreach (var screenshotsFolders in game.ScreenshotsFolders)
{
screenshotsFolders.ScreenshotsFolder = CommonPluginsStores.PlayniteTools.StringExpandWithStores
(
PluginDatabase.PlayniteApi.Database.Games.Get(game.Id),
screenshotsFolders.ScreenshotsFolder
);
}
activateGlobalProgress.CurrentProgressValue++;
}
this.Dispatcher.BeginInvoke((Action) delegate
{
listGameScreenshots.Sort((x, y) => x.Name.CompareTo(y.Name));
PART_ListGameScreenshot.ItemsSource = null;
PART_ListGameScreenshot.ItemsSource = listGameScreenshots;
TextboxSearch_TextChanged(null, null);
});
}
catch (Exception ex)
{
Common.LogError(ex, false, true, PluginDatabase.PluginName);
}
}, globalProgressOptions);
}
public void MoveToFolderToSave(Game game)
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
$"{PluginName} - {resources.GetString("LOCSsvMovingToSave")}",
false
);
globalProgressOptions.IsIndeterminate = true;
PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
MoveToFolderToSaveWithNoLoader(game);
}, globalProgressOptions);
}
public void RefreshData(List <Guid> Ids)
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
$"{PluginName} - {resources.GetString("LOCCommonRefreshGameData")}",
true
);
globalProgressOptions.IsIndeterminate = false;
PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
string CancelText = string.Empty;
activateGlobalProgress.ProgressMaxValue = Ids.Count;
try
{
foreach (Guid Id in Ids)
{
if (activateGlobalProgress.CancelToken.IsCancellationRequested)
{
CancelText = " canceled";
break;
}
GameSettings gameSettings = GetGameSettings(Id);
if (gameSettings != null)
{
SetDataFromSettings(gameSettings);
}
activateGlobalProgress.CurrentProgressValue++;
}
}
catch (Exception ex)
{
Common.LogError(ex, false, true, PluginName);
}
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
logger.Info($"Task RefreshData(){CancelText} - {string.Format("{0:00}:{1:00}.{2:00}", ts.Minutes, ts.Seconds, ts.Milliseconds / 10)} for {activateGlobalProgress.CurrentProgressValue}/{Ids.Count} items");
}, globalProgressOptions);
}
public virtual void GetAllDatas()
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
$"{PluginName} - {resources.GetString("LOCCommonGettingAllDatas")}",
true
);
globalProgressOptions.IsIndeterminate = false;
_PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
try
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
var PlayniteDb = _PlayniteApi.Database.Games.Where(x => x.Hidden == false);
activateGlobalProgress.ProgressMaxValue = (double)PlayniteDb.Count();
string CancelText = string.Empty;
foreach (Game game in PlayniteDb)
{
if (activateGlobalProgress.CancelToken.IsCancellationRequested)
{
CancelText = " canceled";
break;
}
Thread.Sleep(10);
Get(game);
activateGlobalProgress.CurrentProgressValue++;
}
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
logger.Info($"{PluginName} - Task GetAllDatas(){CancelText} - {string.Format("{0:00}:{1:00}.{2:00}", ts.Minutes, ts.Seconds, ts.Milliseconds / 10)} for {activateGlobalProgress.CurrentProgressValue}/{(double)PlayniteDb.Count()} items");
}
catch (Exception ex)
{
Common.LogError(ex, PluginName);
}
}, globalProgressOptions);
}
private void PART_BtConvert_Click(object sender, RoutedEventArgs e)
{
int index = int.Parse(((Button)sender).Tag.ToString());
string FilePath = _backgroundImagesEdited[index].FullPath;
string VideoPath = string.Empty;
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
resources.GetString("LOCCommonConverting"),
false
);
globalProgressOptions.IsIndeterminate = true;
var ProgressDownload = PluginDatabase.PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
try
{
VideoPath = ExtractAnimatedImageAndConvert(FilePath);
}
catch (Exception ex)
{
Common.LogError(ex, false, true, "BackgroundChanger");
}
}, globalProgressOptions);
if (!VideoPath.IsNullOrEmpty() && File.Exists(VideoPath))
{
PART_BtDelete_Click(sender, e);
_backgroundImagesEdited.Add(new ItemImage
{
Name = VideoPath
});
PART_LbBackgroundImages.ItemsSource = null;
PART_LbBackgroundImages.ItemsSource = _backgroundImagesEdited;
}
}
public void MoveToFolderToSaveAll()
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
$"{PluginName} - {resources.GetString("LOCSsvMovingToSave")}",
true
);
globalProgressOptions.IsIndeterminate = false;
PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
string CancelText = string.Empty;
activateGlobalProgress.ProgressMaxValue = Database.Items.Count;
foreach (var item in Database.Items)
{
if (activateGlobalProgress.CancelToken.IsCancellationRequested)
{
CancelText = " canceled";
break;
}
try
{
MoveToFolderToSaveWithNoLoader(item.Key);
}
catch (Exception ex)
{
Common.LogError(ex, false, true, PluginName);
}
activateGlobalProgress.CurrentProgressValue++;
}
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
logger.Info($"MoveToFolderToSaveAll{CancelText} - {string.Format("{0:00}:{1:00}.{2:00}", ts.Minutes, ts.Seconds, ts.Milliseconds / 10)}");
}, globalProgressOptions);
}
private void Button_Click(object sender, RoutedEventArgs e)
{
btnRefresh.IsEnabled = false;
var progressOptions =
new GlobalProgressOptions("Downloading LaunchBox Metadata...", false)
{
IsIndeterminate = false
};
_plugin.PlayniteApi.Dialogs.ActivateGlobalProgress((progressAction) =>
{
try
{
progressAction.ProgressMaxValue = 4;
var result = _plugin.UpdateMetadata(progressAction).Result;
}
catch (Exception)
{
btnRefresh.IsEnabled = true;
}
}, progressOptions);
}
private void UpdateGamesListSizes(List <Game> games, bool forceNonEmpty)
{
var progressOptions = new GlobalProgressOptions(ResourceProvider.GetString("LOCGame_Sizes_Calculator_DialogMessageCalculatingSizes"), true);
progressOptions.IsIndeterminate = false;
PlayniteApi.Dialogs.ActivateGlobalProgress((a) =>
{
a.ProgressMaxValue = games.Count();
foreach (var game in games)
{
a.Text = $"{a.CurrentProgressValue}/{a.ProgressMaxValue} - {game.Name}";
CalculateGameSize(game, forceNonEmpty);
a.CurrentProgressValue++;
if (a.CancelToken.IsCancellationRequested)
{
break;
}
}
}, progressOptions);
PlayniteApi.Dialogs.ShowMessage(ResourceProvider.GetString("LOCGame_Sizes_Calculator_DialogMessageDone"));
}
public void RefreshDataAll()
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
$"{PluginName} - {resources.GetString("LOCCommonRefreshGameData")}",
true
);
globalProgressOptions.IsIndeterminate = false;
PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
string CancelText = string.Empty;
activateGlobalProgress.ProgressMaxValue = Database.Items.Count;
foreach (var item in Database.Items)
{
if (activateGlobalProgress.CancelToken.IsCancellationRequested)
{
CancelText = " canceled";
break;
}
GameSettings gameSettings = GetGameSettings(item.Key);
if (gameSettings != null)
{
SetDataFromSettings(gameSettings);
}
activateGlobalProgress.CurrentProgressValue++;
}
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
logger.Info($"RefreshDataAll(){CancelText} - {string.Format("{0:00}:{1:00}.{2:00}", ts.Minutes, ts.Seconds, ts.Milliseconds / 10)}");
}, globalProgressOptions);
}
public static void RemoveAllTagFromMain(IPlayniteAPI PlayniteApi, string PluginUserDataPath)
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
resources.GetString("LOCCommonRemovingAllTag"),
true
);
globalProgressOptions.IsIndeterminate = false;
PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
var db = PlayniteApi.Database.Games.Where(x => x.Hidden == false);
activateGlobalProgress.ProgressMaxValue = (double)db.Count();
string CancelText = string.Empty;
foreach (Game game in db)
{
if (activateGlobalProgress.CancelToken.IsCancellationRequested)
{
CancelText = " canceled";
break;
}
RemoveAllTag(PlayniteApi, game);
activateGlobalProgress.CurrentProgressValue++;
}
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
logger.Info($"HowLongToBeat - Task RemoveAllTagFromMain(){CancelText} - {String.Format("{0:00}:{1:00}.{2:00}", ts.Minutes, ts.Seconds, ts.Milliseconds / 10)}");
}, globalProgressOptions);
}
public void ConvertDB(IPlayniteAPI PlayniteApi)
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
"CheckLocalizations - Database migration",
false
);
globalProgressOptions.IsIndeterminate = true;
PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
logger.Info($"CheckLocalizations - ConvertDB()");
int Converted = 0;
foreach (var item in Items)
{
try
{
if (PlayniteApi.Database.Games.Get(item.Key) != null)
{
GameLocalizations gameLocalizations = CheckLocalizations.PluginDatabase.Get(item.Key, true);
foreach (var localization in item.Value)
{
gameLocalizations.Items.Add(new Localization
{
Language = localization.Language,
Audio = localization.Audio,
Ui = localization.Ui,
Sub = localization.Sub,
IsManual = false,
Notes = localization.Notes
});
}
ItemsManual.TryGetValue(item.Key, out List <GameLocalizationOld> localizationManual);
if (localizationManual != null && localizationManual.Count > 0)
{
foreach (var localization in localizationManual)
{
gameLocalizations.Items.Add(new Localization
{
Language = localization.Language,
Audio = localization.Audio,
Ui = localization.Ui,
Sub = localization.Sub,
IsManual = true,
Notes = localization.Notes
});
}
}
Thread.Sleep(10);
CheckLocalizations.PluginDatabase.Add(gameLocalizations);
Converted++;
}
else
{
logger.Warn($"CheckLocalizations - Game is deleted - {item.Key.ToString()}");
}
}
catch (Exception ex)
{
Common.LogError(ex, "CheckLocalizations", $"Failed to load ConvertDB from {item.Key.ToString()}");
}
}
logger.Info($"CheckLocalizations - Converted {Converted} / {Items.Count}");
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
logger.Info($"CheckLocalizations - Migration - {String.Format("{0:00}:{1:00}.{2:00}", ts.Minutes, ts.Seconds, ts.Milliseconds / 10)}");
}, globalProgressOptions);
IsOld = false;
}
public GlobalProgressResult ActivateGlobalProgress(Action <GlobalProgressActionArgs> progresAction, GlobalProgressOptions progressArgs)
{
return(null);
}
// To add new game menu items override GetGameMenuItems
public override IEnumerable <GameMenuItem> GetGameMenuItems(GetGameMenuItemsArgs args)
{
Game GameMenu = args.Games.First();
List <Guid> Ids = args.Games.Select(x => x.Id).ToList();
GameScreenshots gameScreenshots = PluginDatabase.Get(GameMenu);
List <GameMenuItem> gameMenuItems = new List <GameMenuItem>();
if (gameScreenshots.HasData)
{
gameMenuItems.Add(new GameMenuItem
{
// Delete & download localizations data for the selected game
MenuSection = resources.GetString("LOCSsv"),
Description = resources.GetString("LOCSsvViewScreenshots"),
Action = (gameMenuItem) =>
{
WindowOptions windowOptions = new WindowOptions
{
ShowMinimizeButton = false,
ShowMaximizeButton = true,
ShowCloseButton = true
};
var ViewExtension = new SsvScreenshotsView(PluginDatabase.GameContext);
Window windowExtension = PlayniteUiHelper.CreateExtensionWindow(PlayniteApi, resources.GetString("LOCSsvTitle"), ViewExtension, windowOptions);
windowExtension.ResizeMode = ResizeMode.CanResize;
windowExtension.ShowDialog();
}
});
if (gameScreenshots.ScreenshotsFolders != null && gameScreenshots.ScreenshotsFolders.Count != 0 && gameScreenshots.FoldersExist)
{
gameMenuItems.Add(new GameMenuItem
{
// Open directory
MenuSection = resources.GetString("LOCSsv"),
Description = resources.GetString("LOCSsvOpenScreenshotsDirectory"),
Action = (gameMenuItem) =>
{
foreach (string Folder in gameScreenshots.ScreenshotsFolders)
{
Process.Start(Folder);
}
}
});
}
if (gameScreenshots.Items.Count > 0 && PluginDatabase.PluginSettings.Settings.EnableFolderToSave)
{
gameMenuItems.Add(new GameMenuItem
{
MenuSection = resources.GetString("LOCSsv"),
Description = resources.GetString("LOCSsvMoveToSave"),
Action = (gameMenuItem) =>
{
if (Ids.Count == 1)
{
PluginDatabase.MoveToFolderToSave(GameMenu);
}
else
{
PluginDatabase.MoveToFolderToSave(Ids);
}
}
});
}
if (gameScreenshots.Items.Count > 0)
{
gameMenuItems.Add(new GameMenuItem
{
MenuSection = resources.GetString("LOCSsv"),
Description = resources.GetString("LOCSsvConvertToJPG"),
Action = (gameMenuItem) =>
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
$"{PluginDatabase.PluginName} - {resources.GetString("LOCCommonConverting")}",
true
);
globalProgressOptions.IsIndeterminate = Ids.Count == 1;
PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
string CancelText = string.Empty;
if (Ids.Count > 1)
{
activateGlobalProgress.ProgressMaxValue = Ids.Count;
}
try
{
Ids.ForEach(y =>
{
GameScreenshots data = PluginDatabase.Get(y);
if (data.HasData)
{
bool HasConvert = false;
data.Items.ForEach(x =>
{
if (activateGlobalProgress.CancelToken.IsCancellationRequested)
{
CancelText = " canceled";
return;
}
if (!x.IsVideo)
{
string oldFile = x.FileName;
string newFile = ImageTools.ConvertToJpg(oldFile, PluginDatabase.PluginSettings.Settings.JpgQuality);
if (!newFile.IsNullOrEmpty())
{
DateTime dt = File.GetLastWriteTime(oldFile);
File.SetLastWriteTime(newFile, dt);
FileSystem.DeleteFileSafe(oldFile);
HasConvert = true;
}
}
});
if (HasConvert)
{
GameSettings gameSettings = PluginDatabase.GetGameSettings(y);
if (gameSettings != null)
{
PluginDatabase.SetDataFromSettings(gameSettings);
}
}
if (activateGlobalProgress.CancelToken.IsCancellationRequested)
{
CancelText = " canceled";
return;
}
if (Ids.Count > 1)
{
activateGlobalProgress.CurrentProgressValue++;
}
}
});
}
catch (Exception ex)
{
Common.LogError(ex, false, true, PluginDatabase.PluginName);
}
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
logger.Info($"Task RefreshData(){CancelText} - {string.Format("{0:00}:{1:00}.{2:00}", ts.Minutes, ts.Seconds, ts.Milliseconds / 10)} for {activateGlobalProgress.CurrentProgressValue}/{Ids.Count} items");
}, globalProgressOptions);
}
});
}
gameMenuItems.Add(new GameMenuItem
{
MenuSection = resources.GetString("LOCSsv"),
Description = "-"
});
}
gameMenuItems.Add(new GameMenuItem
{
// Refresh data
MenuSection = resources.GetString("LOCSsv"),
Description = resources.GetString("LOCCommonRefreshGameData"),
Action = (gameMenuItem) =>
{
if (Ids.Count == 1)
{
PluginDatabase.RefreshData(GameMenu);
}
else
{
PluginDatabase.RefreshData(Ids);
}
}
});
#if DEBUG
gameMenuItems.Add(new GameMenuItem
{
MenuSection = resources.GetString("LOCSsv"),
Description = "-"
});
gameMenuItems.Add(new GameMenuItem
{
MenuSection = resources.GetString("LOCSsv"),
Description = "Test",
Action = (mainMenuItem) =>
{
}
});
#endif
return(gameMenuItems);
}
public override void GetAllDatas()
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
$"{PluginName} - {resources.GetString("LOCCommonGettingAllDatas")}",
true
);
globalProgressOptions.IsIndeterminate = false;
_PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
try
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
var PlayniteDb = _PlayniteApi.Database.Games.Where(x => x.Hidden == false);
activateGlobalProgress.ProgressMaxValue = (double)PlayniteDb.Count();
string CancelText = string.Empty;
foreach (Game game in PlayniteDb)
{
if (activateGlobalProgress.CancelToken.IsCancellationRequested)
{
CancelText = " canceled";
break;
}
Thread.Sleep(10);
GameHowLongToBeat gameHowLongToBeat = Get(game, true);
#if DEBUG
logger.Debug($"{PluginName} [Ignored] - {gameHowLongToBeat.Name} - {gameHowLongToBeat.HasData} - {gameHowLongToBeat.IsSaved}");
#endif
if (!gameHowLongToBeat.HasData && !gameHowLongToBeat.IsSaved)
{
List <HltbDataUser> dataSearch = HowLongToBeat.PluginDatabase.howLongToBeatClient.Search(game.Name);
if (dataSearch.Count == 1 && PluginSettings.AutoAccept)
{
gameHowLongToBeat.Items = new List <HltbDataUser>()
{
dataSearch.First()
};
HowLongToBeat.PluginDatabase.Add(gameHowLongToBeat);
}
else
{
if (dataSearch.Count > 0 && PluginSettings.ShowWhenMismatch)
{
HowLongToBeat.PluginDatabase.Get(game);
}
}
}
activateGlobalProgress.CurrentProgressValue++;
}
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
logger.Info($"{PluginName} - Task GetAllDatas(){CancelText} - {string.Format("{0:00}:{1:00}.{2:00}", ts.Minutes, ts.Seconds, ts.Milliseconds / 10)} for {activateGlobalProgress.CurrentProgressValue}/{(double)PlayniteDb.Count()} items");
}
catch (Exception ex)
{
Common.LogError(ex, PluginName);
}
}, globalProgressOptions);
}
public GlobalProgressResult ActivateGlobalProgress(Action <GlobalProgressActionArgs> progresAction, GlobalProgressOptions progressArgs)
{
return(Invoke(() => GlobalProgress.ActivateProgress(progresAction, progressArgs)));
}
public void ConvertDB(IPlayniteAPI PlayniteApi)
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
"GameActivity - Database migration",
false
);
globalProgressOptions.IsIndeterminate = true;
PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
logger.Info($"GameActivity - ConvertDB()");
int Converted = 0;
foreach (var item in Items)
{
try
{
if (PlayniteApi.Database.Games.Get(item.Key) != null)
{
GameActivities GameActivitiesLog = GameActivity.PluginDatabase.Get(item.Key);
foreach (var Activity in item.Value.Activities)
{
DateTime DateSession = (DateTime)Activity.DateSession;
GameActivitiesLog.Items.Add(new Activity
{
DateSession = Activity.DateSession,
SourceID = Activity.SourceID,
ElapsedSeconds = Activity.ElapsedSeconds
});
var ActivitiesDetails = item.Value.GetSessionActivityDetails(DateSession);
List <ActivityDetailsData> ListActivityDetails = new List <ActivityDetailsData>();
foreach (var ActivityDetails in ActivitiesDetails)
{
ListActivityDetails.Add(new ActivityDetailsData
{
Datelog = ActivityDetails.Datelog,
FPS = ActivityDetails.FPS,
CPU = ActivityDetails.CPU,
CPUT = ActivityDetails.CPUT,
GPU = ActivityDetails.GPU,
GPUT = ActivityDetails.GPUT,
RAM = ActivityDetails.RAM
});
}
GameActivitiesLog.ItemsDetails.Items.TryAdd(DateSession, ListActivityDetails);
}
Thread.Sleep(10);
GameActivity.PluginDatabase.Update(GameActivitiesLog);
Converted++;
}
else
{
logger.Warn($"GameActivity - Game is deleted - {item.Key.ToString()}");
}
}
catch (Exception ex)
{
Common.LogError(ex, "GameActivity", $"Failed to load ConvertDB from {item.Key} - {item.Value.GameName}");
}
}
logger.Info($"GameActivity - Converted {Converted} / {Items.Count}");
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
logger.Info($"GameActivity - Migration - {String.Format("{0:00}:{1:00}.{2:00}", ts.Minutes, ts.Seconds, ts.Milliseconds / 10)}");
}, globalProgressOptions);
IsOld = false;
}
// To add new game menu items override GetGameMenuItems
public override List <GameMenuItem> GetGameMenuItems(GetGameMenuItemsArgs args)
{
Game GameMenu = args.Games.First();
GameHowLongToBeat gameHowLongToBeat = PluginDatabase.Get(GameMenu, true);
List <GameMenuItem> gameMenuItems = new List <GameMenuItem>
{
new GameMenuItem {
MenuSection = resources.GetString("LOCHowLongToBeat"),
Description = resources.GetString("LOCHowLongToBeatPluginView"),
Action = (gameMenuItem) =>
{
try
{
gameHowLongToBeat = PluginDatabase.Get(GameMenu);
if (gameHowLongToBeat.HasData)
{
var ViewExtension = new HowLongToBeatView(PlayniteApi, settings, gameHowLongToBeat);
Window windowExtension = PlayniteUiHelper.CreateExtensionWindow(PlayniteApi, "HowLongToBeat", ViewExtension);
windowExtension.ShowDialog();
var TaskIntegrationUI = Task.Run(() =>
{
howLongToBeatUI.RefreshElements(HowLongToBeatDatabase.GameSelected);
});
}
}
catch (Exception ex)
{
Common.LogError(ex, "HowLongToBeat", $"Error to load game data for {args.Games.First().Name}");
PlayniteApi.Dialogs.ShowErrorMessage(resources.GetString("LOCDatabaseErroTitle"), "HowLongToBeat");
}
}
}
};
if (gameHowLongToBeat.HasData)
{
gameMenuItems.Add(new GameMenuItem
{
MenuSection = resources.GetString("LOCHowLongToBeat"),
Description = resources.GetString("LOCHowLongToBeatSetCurrentTimeManual"),
Action = (mainMenuItem) =>
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
$"HowLongToBeat - {resources.GetString("LOCCommonProcessing")}",
false
);
globalProgressOptions.IsIndeterminate = true;
PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
PluginDatabase.SetCurrentPlayTime(GameMenu, 0);
}, globalProgressOptions);
}
});
gameMenuItems.Add(new GameMenuItem
{
MenuSection = resources.GetString("LOCHowLongToBeat"),
Description = resources.GetString("LOCCommonDeleteGameData"),
Action = (gameMenuItem) =>
{
PluginDatabase.Remove(GameMenu.Id);
howLongToBeatUI.RefreshElements(HowLongToBeatDatabase.GameSelected);
}
});
}
#if DEBUG
gameMenuItems.Add(new GameMenuItem
{
MenuSection = resources.GetString("LOCHowLongToBeat"),
Description = "Test",
Action = (mainMenuItem) => { }
});
#endif
return(gameMenuItems);
}
public override IEnumerable <GameMenuItem> GetGameMenuItems(GetGameMenuItemsArgs args)
{
var logosSection = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemSectionLogos");
var videosSection = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemSectionVideos");
var videosMicroSection = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemSectionMicrovideos");
//TODO Move each action to separate methods?
var gameMenuItems = new List <GameMenuItem>
{
new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemDescriptionDownloadSteamLogosSelectedGames"),
MenuSection = $"Extra Metadata|{logosSection}",
Action = _ => {
var overwrite = GetBoolFromYesNoDialog(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageOverwriteLogosChoice"));
var progressOptions = new GlobalProgressOptions(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageDownloadingLogosSteam"), true);
progressOptions.IsIndeterminate = false;
PlayniteApi.Dialogs.ActivateGlobalProgress((a) =>
{
var games = args.Games.Distinct();
a.ProgressMaxValue = games.Count();
foreach (var game in games)
{
if (a.CancelToken.IsCancellationRequested)
{
break;
}
logosDownloader.DownloadSteamLogo(game, overwrite, false);
a.CurrentProgressValue++;
}
;
}, progressOptions);
PlayniteApi.Dialogs.ShowMessage(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageDone"), "Extra Metadata Loader");
}
},
new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemDescriptionDownloadSgdbLogosSelectedGames"),
MenuSection = $"Extra Metadata|{logosSection}",
Action = _ => {
var overwrite = GetBoolFromYesNoDialog(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageOverwriteLogosChoice"));
var progressOptions = new GlobalProgressOptions(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageDownloadingLogosSgdb"), true);
progressOptions.IsIndeterminate = false;
PlayniteApi.Dialogs.ActivateGlobalProgress((a) =>
{
var games = args.Games.Distinct();
a.ProgressMaxValue = games.Count();
foreach (var game in games)
{
if (a.CancelToken.IsCancellationRequested)
{
break;
}
logosDownloader.DownloadSgdbLogo(game, overwrite, false);
a.CurrentProgressValue++;
}
;
}, progressOptions);
PlayniteApi.Dialogs.ShowMessage(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageDone"), "Extra Metadata Loader");
}
},
new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemDescriptionDownloadGoogleLogoSelectedGame"),
MenuSection = $"Extra Metadata|{logosSection}",
Action = _ =>
{
CreateGoogleWindow();
}
},
new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemDescriptionSetLogoFromFile"),
MenuSection = $"Extra Metadata|{logosSection}",
Action = _ => {
var game = args.Games.Last();
var filePath = PlayniteApi.Dialogs.SelectFile("Logo|*.png");
if (!filePath.IsNullOrEmpty())
{
var logoPath = extraMetadataHelper.GetGameLogoPath(game, true);
var fileCopied = IoHelper.MoveFile(filePath, logoPath, true);
if (settings.Settings.ProcessLogosOnDownload && fileCopied)
{
logosDownloader.ProcessLogoImage(logoPath);
}
PlayniteApi.Dialogs.ShowMessage(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageDone"), "Extra Metadata Loader");
}
}
},
new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemDescriptionDeleteLogosSelectedGames"),
MenuSection = $"Extra Metadata|{logosSection}",
Action = _ => {
foreach (var game in args.Games.Distinct())
{
extraMetadataHelper.DeleteGameLogo(game);
}
;
PlayniteApi.Dialogs.ShowMessage(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageDone"), "Extra Metadata Loader");
}
},
new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemDescriptionDownloadSteamVideosSelectedGames"),
MenuSection = $"Extra Metadata|{videosSection}|{videosSection}",
Action = _ =>
{
if (!ValidateExecutablesSettings(true, false))
{
return;
}
var overwrite = GetBoolFromYesNoDialog(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageOverwriteVideosChoice"));
var progressOptions = new GlobalProgressOptions(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageDownloadingVideosSteam"), true);
progressOptions.IsIndeterminate = false;
ClearVideoSources();
PlayniteApi.Dialogs.ActivateGlobalProgress((a) =>
{
var games = args.Games.Distinct();
a.ProgressMaxValue = games.Count();
foreach (var game in games)
{
if (a.CancelToken.IsCancellationRequested)
{
break;
}
videosDownloader.DownloadSteamVideo(game, overwrite, false, true, false);
a.CurrentProgressValue++;
}
;
}, progressOptions);
UpdatePlayersData();
PlayniteApi.Dialogs.ShowMessage(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageDone"), "Extra Metadata Loader");
}
},
new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemDescriptionDownloadVideoFromYoutube"),
MenuSection = $"Extra Metadata|{videosSection}|{videosSection}",
Action = _ =>
{
ClearVideoSources();
if (!ValidateExecutablesSettings(true, true))
{
return;
}
CreateYoutubeWindow();
UpdatePlayersData();
}
},
new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemDescriptionDownloadSteamVideosMicroSelectedGames"),
MenuSection = $"Extra Metadata|{videosSection}|{videosMicroSection}",
Action = _ =>
{
if (!ValidateExecutablesSettings(true, false))
{
return;
}
ClearVideoSources();
var overwrite = GetBoolFromYesNoDialog(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageOverwriteVideosChoice"));
var progressOptions = new GlobalProgressOptions(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageDownloadingVideosMicroSteam"), true);
progressOptions.IsIndeterminate = false;
PlayniteApi.Dialogs.ActivateGlobalProgress((a) =>
{
var games = args.Games.Distinct();
a.ProgressMaxValue = games.Count();
foreach (var game in games)
{
if (a.CancelToken.IsCancellationRequested)
{
break;
}
videosDownloader.DownloadSteamVideo(game, overwrite, false, false, true);
a.CurrentProgressValue++;
}
;
}, progressOptions);
UpdatePlayersData();
PlayniteApi.Dialogs.ShowMessage(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageDone"), "Extra Metadata Loader");
}
},
new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemDescriptionOpenExtraMetadataDirectory"),
MenuSection = $"Extra Metadata",
Action = _ =>
{
foreach (var game in args.Games.Distinct())
{
Process.Start(extraMetadataHelper.GetExtraMetadataDirectory(game, true));
}
;
}
},
new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemDescriptionGenerateMicroFromVideo"),
MenuSection = $"Extra Metadata|{videosSection}|{videosMicroSection}",
Action = _ =>
{
if (!ValidateExecutablesSettings(true, false))
{
return;
}
ClearVideoSources();
var overwrite = GetBoolFromYesNoDialog(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageOverwriteVideosChoice"));
var progressOptions = new GlobalProgressOptions(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageGeneratingMicroVideosFromVideos"), true);
progressOptions.IsIndeterminate = false;
PlayniteApi.Dialogs.ActivateGlobalProgress((a) =>
{
var games = args.Games.Distinct();
a.ProgressMaxValue = games.Count();
foreach (var game in games)
{
if (a.CancelToken.IsCancellationRequested)
{
break;
}
videosDownloader.ConvertVideoToMicro(game, overwrite);
a.CurrentProgressValue++;
}
;
}, progressOptions);
UpdatePlayersData();
PlayniteApi.Dialogs.ShowMessage(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageDone"), "Extra Metadata Loader");
}
},
new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemDescriptionSetVideoFromSelectionToSelGame"),
MenuSection = $"Extra Metadata|{videosSection}|{videosSection}",
Action = _ =>
{
if (!ValidateExecutablesSettings(true, false))
{
return;
}
ClearVideoSources();
PlayniteApi.Dialogs.ActivateGlobalProgress((a) =>
{
videosDownloader.SelectedDialogFileToVideo(args.Games[0]);
}, new GlobalProgressOptions(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogProcessSettingVideoFromSelFile")));
UpdatePlayersData();
PlayniteApi.Dialogs.ShowMessage(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageDone"), "Extra Metadata Loader");
}
},
new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemDescriptionDeleteVideosSelectedGames"),
MenuSection = $"Extra Metadata|{videosSection}|{videosSection}",
Action = _ =>
{
ClearVideoSources();
foreach (var game in args.Games.Distinct())
{
extraMetadataHelper.DeleteGameVideo(game);
}
;
UpdatePlayersData();
PlayniteApi.Dialogs.ShowMessage(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageDone"), "Extra Metadata Loader");
}
},
new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemDescriptionDeleteVideosMicroSelectedGames"),
MenuSection = $"Extra Metadata|{videosSection}|{videosMicroSection}",
Action = _ =>
{
ClearVideoSources();
foreach (var game in args.Games.Distinct())
{
extraMetadataHelper.DeleteGameVideoMicro(game);
}
;
UpdatePlayersData();
PlayniteApi.Dialogs.ShowMessage(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageDone"), "Extra Metadata Loader");
}
}
};
if (settings.Settings.EnableYoutubeSearch)
{
gameMenuItems.Add(new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemViewYoutubeReview"),
MenuSection = $"{videosSection}",
Action = _ =>
{
ClearVideoSources();
var game = args.Games.Last();
var searchTerm = $"{game.Name} review";
var searchItems = YoutubeCommon.GetYoutubeSearchResults(searchTerm, false);
if (searchItems.Count > 0)
{
ViewYoutubeVideo(searchItems.First().VideoId);
}
else
{
PlayniteApi.Dialogs.ShowMessage(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageVideoNotFound"));
}
UpdatePlayersData();
}
});
gameMenuItems.Add(new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemViewYoutubeGameplay"),
MenuSection = $"{videosSection}",
Action = _ =>
{
ClearVideoSources();
var game = args.Games.Last();
var searchTerm = $"{game.Name} gameplay";
var searchItems = YoutubeCommon.GetYoutubeSearchResults(searchTerm, false);
if (searchItems.Count > 0)
{
ViewYoutubeVideo(searchItems.First().VideoId);
}
else
{
PlayniteApi.Dialogs.ShowMessage(ResourceProvider.GetString("LOCExtra_Metadata_Loader_DialogMessageVideoNotFound"));
}
UpdatePlayersData();
}
});
gameMenuItems.Add(new GameMenuItem
{
Description = ResourceProvider.GetString("LOCExtra_Metadata_Loader_MenuItemViewYoutubeSearch"),
MenuSection = $"{videosSection}",
Action = _ =>
{
ClearVideoSources();
var game = args.Games.Last();
var searchTerm = $"{game.Name}";
CreateYoutubeWindow(false, false, searchTerm);
UpdatePlayersData();
}
});
}
return(gameMenuItems);
}
public void ConvertDB(IPlayniteAPI PlayniteApi)
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
"HowLongToBeat - Database migration",
false
);
globalProgressOptions.IsIndeterminate = true;
PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
logger.Info($"HowLongToBeat - ConvertDB()");
int Converted = 0;
foreach (var item in Items)
{
try
{
if (PlayniteApi.Database.Games.Get(item.Key) != null)
{
GameHowLongToBeat gameHowLongToBeat = HowLongToBeat.PluginDatabase.Get(item.Key, true);
HltbDataUser hltbDataUser = new HltbDataUser
{
Id = item.Value.GameHltbData.Id,
Name = item.Value.GameHltbData.Name,
Url = item.Value.GameHltbData.Url,
UrlImg = item.Value.GameHltbData.UrlImg,
GameHltbData = new HltbData
{
MainStory = item.Value.GameHltbData.MainStory,
MainExtra = item.Value.GameHltbData.MainExtra,
Completionist = item.Value.GameHltbData.Completionist,
Solo = item.Value.GameHltbData.Solo,
CoOp = item.Value.GameHltbData.CoOp,
Vs = item.Value.GameHltbData.Vs
}
};
gameHowLongToBeat.Items = new List <HltbDataUser> {
hltbDataUser
};
Thread.Sleep(10);
HowLongToBeat.PluginDatabase.Add(gameHowLongToBeat);
Converted++;
}
else
{
logger.Warn($"HowLongToBeat - Game is deleted - {item.Key.ToString()}");
}
}
catch (Exception ex)
{
Common.LogError(ex, "SuccessStory", $"Failed to load ConvertDB from {item.Key.ToString()}");
}
}
logger.Info($"HowLongToBeat - Converted {Converted} / {Items.Count}");
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
logger.Info($"HowLongToBeat - Migration - {String.Format("{0:00}:{1:00}.{2:00}", ts.Minutes, ts.Seconds, ts.Milliseconds / 10)}");
}, globalProgressOptions);
IsOld = false;
}
public static void GetAllDataFromMain(IPlayniteAPI PlayniteApi, string PluginUserDataPath, HowLongToBeatSettings settings)
{
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
resources.GetString("LOCCommonGettingAllDatas"),
true
);
globalProgressOptions.IsIndeterminate = false;
PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
var db = PlayniteApi.Database.Games.Where(x => x.Hidden == false);
activateGlobalProgress.ProgressMaxValue = (double)db.Count();
string CancelText = string.Empty;
foreach (Game game in db)
{
if (activateGlobalProgress.CancelToken.IsCancellationRequested)
{
CancelText = " canceled";
break;
}
if (!HowLongToBeatData.HaveData(game.Id, PluginUserDataPath))
{
List <HltbData> dataSearch = new HowLongToBeatClient().Search(game.Name);
if (dataSearch.Count == 1 && settings.AutoAccept)
{
HowLongToBeatData.SaveData(game.Id, dataSearch[0], PluginUserDataPath);
if (settings.EnableTag)
{
HowLongToBeatData.AddAllTag(PlayniteApi, game, PluginUserDataPath);
}
}
else
{
if (dataSearch.Count > 0 && settings.ShowWhenMismatch)
{
Application.Current.Dispatcher.BeginInvoke((Action) delegate
{
string FileGameData = PluginUserDataPath + "\\howlongtobeat\\" + game.Id.ToString() + ".json";
var ViewExtension = new HowLongToBeatSelect(dataSearch, FileGameData, game.Name);
Window windowExtension = PlayniteUiHelper.CreateExtensionWindow(PlayniteApi, resources.GetString("LOCSelection"), ViewExtension);
windowExtension.ShowDialog();
if (settings.EnableTag)
{
HowLongToBeatData.AddAllTag(PlayniteApi, game, PluginUserDataPath);
}
}).Wait();
}
}
}
activateGlobalProgress.CurrentProgressValue++;
}
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
logger.Info($"HowLongToBeat - Task GetAllDataFromMain(){CancelText} - {String.Format("{0:00}:{1:00}.{2:00}", ts.Minutes, ts.Seconds, ts.Milliseconds / 10)}");
}, globalProgressOptions);
}
public void SetTagsToGenres(bool OnlyToDay = false, Game gameUpdated = null)
{
if (PluginSettings.ListTagsToGenres?.Count == 0)
{
API.Instance.Dialogs.ShowErrorMessage(resources.GetString("LOCLmNoEquivalence"), resources.GetString("LOCLm"));
return;
}
GlobalProgressOptions globalProgressOptions = new GlobalProgressOptions(
$"LibraryManagement - {resources.GetString("LOCLmActionInProgress")}",
true
);
globalProgressOptions.IsIndeterminate = false;
PlayniteApi.Dialogs.ActivateGlobalProgress((activateGlobalProgress) =>
{
try
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
IEnumerable <Game> PlayniteDb = PlayniteApi.Database.Games.Where(x => x.Hidden == true || x.Hidden == false);
if (OnlyToDay)
{
PlayniteDb = PlayniteApi.Database.Games
.Where(x => x.Added != null && x.Added > PluginSettings.LastAutoLibUpdateAssetsDownload);
}
activateGlobalProgress.ProgressMaxValue = (double)PlayniteDb.Count();
string CancelText = string.Empty;
List <Game> gamesUpdated = new List <Game>();
foreach (Game game in PlayniteDb)
{
if (activateGlobalProgress.CancelToken.IsCancellationRequested)
{
CancelText = " canceled";
break;
}
try
{
Thread.Sleep(10);
if (UpdateTagsToGenres(game))
{
gamesUpdated.Add(game);
}
}
catch (Exception ex)
{
Common.LogError(ex, false, true, "LibraryManagement");
}
activateGlobalProgress.CurrentProgressValue++;
}
if (gamesUpdated.Count > 0 && PluginSettings.NotifitcationAfterUpdate)
{
PlayniteApi.Notifications.Add(new NotificationMessage(
$"LibraryManagement-UpdateTagsToGenres",
$"LibraryManagement" + System.Environment.NewLine + string.Format(resources.GetString("LOCLmNotificationsUpdate"), gamesUpdated.Count, resources.GetString("LOCLmTagsToGenres")),
NotificationType.Info,
() => {
ListDataUpdated listDataUpdated = new ListDataUpdated(gamesUpdated);
Window windowExtension = PlayniteUiHelper.CreateExtensionWindow(PlayniteApi, resources.GetString("LOCLmTagsToGenresUpdated"), listDataUpdated);
windowExtension.ShowDialog();
}
));
}
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
logger.Info($"Task SetTags(){CancelText} - {string.Format("{0:00}:{1:00}.{2:00}", ts.Minutes, ts.Seconds, ts.Milliseconds / 10)} for {activateGlobalProgress.CurrentProgressValue}/{(double)PlayniteDb.Count()} items");
}
catch (Exception ex)
{
Common.LogError(ex, false, true, "LibraryManagement");
}
}, globalProgressOptions);
}
