auto-creamapi-2/auto-creamapi/ViewModels/MainViewModel.cs

441 lines
13 KiB
C#

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Threading.Tasks;
using auto_creamapi.Models;
using auto_creamapi.Services;
using auto_creamapi.Utils;
using Microsoft.Extensions.Logging;
using Microsoft.Win32;
using MvvmCross.Commands;
using MvvmCross.Navigation;
using MvvmCross.ViewModels;
namespace auto_creamapi.ViewModels
{
public class MainViewModel : MvxViewModel
{
private readonly ICacheService _cache;
private readonly ICreamConfigService _config;
private readonly ILogger<MainViewModel> _logger;
private readonly ICreamDllService _dll;
private readonly IMvxNavigationService _navigationService;
private int _appId;
private bool _configExists;
private ObservableCollection<SteamApp> _dlcs;
private bool _dllApplied;
private string _dllPath;
private bool _extraProtection;
private string _gameName;
private string _lang;
private ObservableCollection<string> _languages;
//private readonly IDownloadCreamApiService _download;
private bool _mainWindowEnabled;
private bool _offline;
private string _status;
private bool _unlockAll;
private bool _useSteamDb;
private bool _ignoreUnknown;
//private const string DlcRegexPattern = @"(?<id>.*) *= *(?<name>.*)";
public MainViewModel(ICacheService cache, ICreamConfigService config, ICreamDllService dll,
IMvxNavigationService navigationService, ILoggerFactory loggerFactory)
{
_navigationService = navigationService;
_logger = loggerFactory.CreateLogger<MainViewModel>();
_cache = cache;
_config = config;
_dll = dll;
//_download = download;
}
public override async void Prepare()
{
base.Prepare();
_config.Initialize();
var tasks = new List<Task> { _cache.Initialize() };
if (!File.Exists("steam_api.dll") | !File.Exists("steam_api64.dll"))
tasks.Add(_navigationService.Navigate<DownloadViewModel>());
//tasks.Add(_navigationService.Navigate<DownloadViewModel>());
tasks.Add(_dll.Initialize());
await Task.WhenAll(tasks).ConfigureAwait(false);
Languages = new ObservableCollection<string>(Misc.DefaultLanguages);
ResetForm();
UseSteamDb = true;
MainWindowEnabled = true;
Status = "Ready.";
}
// // COMMANDS // //
public IMvxCommand OpenFileCommand => new MvxAsyncCommand(OpenFile);
public IMvxCommand SearchCommand => new MvxAsyncCommand(async () => await Search().ConfigureAwait(false)); //Command(Search);
public IMvxCommand GetListOfDlcCommand => new MvxAsyncCommand(GetListOfDlc);
public IMvxCommand SaveCommand => new MvxCommand(Save);
public IMvxCommand ResetFormCommand => new MvxCommand(ResetForm);
public IMvxCommand GoToForumThreadCommand => new MvxCommand(GoToForumThread);
public IMvxCommand GoToSteamdbCommand => new MvxCommand(GoToSteamdb);
// // ATTRIBUTES // //
public bool MainWindowEnabled
{
get => _mainWindowEnabled;
set
{
_mainWindowEnabled = value;
RaisePropertyChanged(() => MainWindowEnabled);
}
}
public string DllPath
{
get => _dllPath;
set
{
_dllPath = value;
RaisePropertyChanged(() => DllPath);
}
}
public string GameName
{
get => _gameName;
set
{
_gameName = value;
RaisePropertyChanged(() => GameName);
}
}
public int AppId
{
get => _appId;
set
{
_appId = value;
RaisePropertyChanged(() => AppId);
SetNameById();
}
}
public string Lang
{
get => _lang;
set
{
_lang = value;
RaisePropertyChanged(() => Lang);
}
}
public bool Offline
{
get => _offline;
set
{
_offline = value;
RaisePropertyChanged(() => Offline);
}
}
public bool ExtraProtection
{
get => _extraProtection;
set
{
_extraProtection = value;
RaisePropertyChanged(() => ExtraProtection);
}
}
public bool UnlockAll
{
get => _unlockAll;
set
{
_unlockAll = value;
RaisePropertyChanged(() => UnlockAll);
}
}
public bool UseSteamDb
{
get => _useSteamDb;
set
{
_useSteamDb = value;
RaisePropertyChanged(() => UseSteamDb);
}
}
public ObservableCollection<SteamApp> Dlcs
{
get => _dlcs;
set
{
_dlcs = value;
RaisePropertyChanged(() => Dlcs);
}
}
public bool DllApplied
{
get => _dllApplied;
set
{
_dllApplied = value;
RaisePropertyChanged(() => DllApplied);
}
}
public bool ConfigExists
{
get => _configExists;
set
{
_configExists = value;
RaisePropertyChanged(() => ConfigExists);
}
}
public string Status
{
get => _status;
set
{
_status = value;
RaisePropertyChanged(() => Status);
}
}
public ObservableCollection<string> Languages
{
get => _languages;
set
{
_languages = value;
RaisePropertyChanged(() => Languages);
}
}
public bool IgnoreUnknown
{
get => _ignoreUnknown;
set
{
_ignoreUnknown = value;
RaisePropertyChanged(() => IgnoreUnknown);
}
}
private async Task OpenFile()
{
Status = "Waiting for file...";
var dialog = new OpenFileDialog
{
Filter = "SteamAPI DLL|steam_api.dll;steam_api64.dll|" +
"All files (*.*)|*.*",
Multiselect = false,
Title = "Select SteamAPI DLL..."
};
if (dialog.ShowDialog() == true)
{
var filePath = dialog.FileName;
DllPath = filePath;
var dirPath = Path.GetDirectoryName(filePath);
if (dirPath != null)
{
_config.ReadFile(Path.Combine(dirPath, "cream_api.ini"));
ResetForm();
_dll.TargetPath = dirPath;
_dll.CheckIfDllExistsAtTarget();
CheckSetupStatus();
if (!ConfigExists)
{
var separator = Path.DirectorySeparatorChar;
var strings = new List<string>(dirPath.Split(separator));
var index = strings.Contains("common") ? strings.FindIndex(x => x.Equals("common")) + 1 : -1;
if (index == -1)
index = strings.Contains("steamapps")
? strings.FindIndex(x => x.Equals("steamapps")) + 2
: -1;
var s = index > -1 ? strings[index] : null;
if (s != null) GameName = s;
await Search().ConfigureAwait(false);
// await GetListOfDlc().ConfigureAwait(false);
}
Status = "Ready.";
}
}
else
{
Status = "File selection canceled.";
}
}
private async Task Search()
{
if (!string.IsNullOrEmpty(GameName))
{
var app = _cache.GetAppByName(GameName);
if (app != null)
{
GameName = app.Name;
AppId = app.AppId;
}
else
{
MainWindowEnabled = false;
var navigate = _navigationService.Navigate<SearchResultViewModel, IEnumerable<SteamApp>, SteamApp>(
_cache.GetListOfAppsByName(GameName));
await navigate.ConfigureAwait(false);
var navigateResult = navigate.Result;
if (navigateResult != null)
{
GameName = navigateResult.Name;
AppId = navigateResult.AppId;
}
}
// await GetListOfDlc().ConfigureAwait(false);
}
else
{
_logger.LogWarning("Empty game name, cannot initiate search!");
}
MainWindowEnabled = true;
}
private async Task GetListOfDlc()
{
Status = "Trying to get DLC, please wait...";
if (AppId > 0)
{
var app = new SteamApp { AppId = AppId, Name = GameName };
var task = _cache.GetListOfDlc(app, UseSteamDb, IgnoreUnknown);
MainWindowEnabled = false;
var listOfDlc = await task.ConfigureAwait(false);
if (task.IsCompletedSuccessfully)
{
listOfDlc.Sort((app1, app2) => app1.AppId.CompareTo(app2.AppId));
Dlcs = new ObservableCollection<SteamApp>(listOfDlc);
Status = $"Got DLC for AppID {AppId} (Count: {Dlcs.Count})";
}
else
{
Status = $"Could not get DLC for AppID {AppId}";
}
MainWindowEnabled = true;
}
else
{
Status = $"Could not get DLC for AppID {AppId}";
_logger.LogError("GetListOfDlc: Invalid AppID {AppId}", AppId);
}
}
private void Save()
{
Status = "Saving...";
_config.SetConfigData(
AppId,
Lang,
UnlockAll,
ExtraProtection,
Offline,
Dlcs
);
_config.SaveFile();
_dll.Save();
CheckSetupStatus();
Status = "Saving successful.";
}
private void ResetForm()
{
AppId = _config.Config.AppId;
Lang = _config.Config.Language;
UnlockAll = _config.Config.UnlockAll;
ExtraProtection = _config.Config.ExtraProtection;
Offline = _config.Config.ForceOffline;
Dlcs = new ObservableCollection<SteamApp>(_config.Config.DlcList);
Status = "Changes have been reset.";
}
private void GoToForumThread()
{
Status = "Opening URL...";
if (AppId > 0)
{
var searchTerm = AppId; //$"{GameName.Replace(" ", "+")}+{appId}";
var destinationUrl =
$"https://cs.rin.ru/forum/search.php?keywords={searchTerm}&terms=any&fid[]=10&sf=firstpost&sr=topics&submit=Search";
var uri = new Uri(destinationUrl);
var process = new ProcessStartInfo(uri.AbsoluteUri)
{
UseShellExecute = true
};
Process.Start(process);
}
else
{
_logger.LogError("OpenURL: Invalid AppID {AppId}", AppId);
Status = $"Could not open URL: Invalid AppID {AppId}";
}
}
private void GoToSteamdb()
{
Status = "Opening URL...";
if (AppId > 0)
{
var searchTerm = AppId; //$"{GameName.Replace(" ", "+")}+{appId}";
var destinationUrl =
$"https://steamdb.info/app/{searchTerm}/dlc/";
var uri = new Uri(destinationUrl);
var process = new ProcessStartInfo(uri.AbsoluteUri)
{
UseShellExecute = true
};
Process.Start(process);
}
else
{
_logger.LogError("OpenURL: Invalid AppID {AppId}", AppId);
Status = $"Could not open URL: Invalid AppID {AppId}";
}
}
private void CheckSetupStatus()
{
DllApplied = _dll.CreamApiApplied();
ConfigExists = _config.ConfigExists();
}
private void SetNameById()
{
if (_appId > 0)
{
var appById = _cache.GetAppById(_appId);
GameName = appById != null ? appById.Name : "";
}
else GameName = "";
}
}
}