public override string GetPackageId()
{
using (var stream = File.OpenRead(FileName))
{
using (var doc = SIDocument.Load(stream))
{
return(doc.Package.ID);
}
}
}
public async Task <SIDocument> GetPackageAsync(string name)
{
if (string.IsNullOrEmpty(_storageOriginsPath))
{
var fileName = Path.GetTempFileName();
try
{
var request = WebRequest.Create($"{_storageUrl}/{Uri.EscapeDataString(name)}"); // TODO: -> HttpClient
using (var response = await request.GetResponseAsync())
using (var stream = response.GetResponseStream())
{
using (var fs = File.Create(fileName))
{
await stream.CopyToAsync(fs);
}
}
_downloadedFiles.Add(fileName);
using (var fs = File.OpenRead(fileName))
{
return(SIDocument.Load(fs));
}
}
finally
{
File.Delete(fileName);
}
}
else
{
var paths = name.Split('\\');
var packagePath = Path.Combine(paths);
var packageOriginPath = Path.Combine(_storageOriginsPath, packagePath);
if (!File.Exists(packageOriginPath))
{
throw new Exception($"Пакет {name} не существует!");
}
return(SIDocument.Load(File.OpenRead(packageOriginPath)));
}
}
private async Task <(SIDocument, string)> BeginNewGameAsync()
{
try
{
var(packageFile, isTemp) = await Package.GetPackageFileAsync();
var tempDir = Path.Combine(Path.GetTempPath(), CommonSettings.AppNameEn, Guid.NewGuid().ToString());
ZipHelper.ExtractToDirectory(packageFile, tempDir);
if (isTemp)
{
File.Delete(packageFile);
}
return(SIDocument.Load(tempDir), tempDir);
}
finally
{
IsProgress = false;
BeginGame.CanBeExecuted = true;
}
}
public async Task <SIDocument> GetPackageAsync(string name)
{
if (string.IsNullOrEmpty(_storageOriginsPath))
{
var fileName = Path.GetTempFileName();
var packageNameParts = name.Split('\\');
var escapedName = string.Join("/", packageNameParts.Select(pnp => Uri.EscapeDataString(pnp)));
var uri = $"{_storageUrl}/{escapedName}";
using (var response = await HttpClient.GetAsync(uri))
{
if (!response.IsSuccessStatusCode)
{
throw new Exception($"Error while accessing \"{uri}\": {await response.Content.ReadAsStringAsync()}!");
}
using var fs = File.Create(fileName);
await response.Content.CopyToAsync(fs);
}
_downloadedFiles.Add(fileName);
return(SIDocument.Load(File.OpenRead(fileName)));
}
else
{
var paths = name.Split('\\');
var packagePath = Path.Combine(paths);
var packageOriginPath = Path.Combine(_storageOriginsPath, packagePath);
if (!File.Exists(packageOriginPath))
{
throw new Exception($"Пакет {name} не существует!");
}
return(SIDocument.Load(File.OpenRead(packageOriginPath)));
}
}
private void CheckPackage()
{
var filePath = cbPackagePath.Text;
if (!File.Exists(filePath))
{
doc = null;
cbPackagePath.Text = "";
return;
}
try
{
using (var stream = File.OpenRead(filePath))
{
doc = SIDocument.Load(stream);
}
}
catch (Exception e)
{
cbPackagePath.Text = "";
MessageBox.Show(this, e.Message);
}
}
/// <summary>
/// Открытие существующего файла
/// </summary>
/// <param name="path">Имя файла</param>
/// <param name="fileStream">Открытый для чтения файл</param>
internal void OpenFile(string path, string search = null, string overridePath = null, Action onSuccess = null)
{
var savingPath = overridePath ?? path;
Task <QDocument> loader() => Task.Run(() =>
{
FileStream stream = null;
try
{
stream = File.Open(path, FileMode.Open, FileAccess.ReadWrite);
// Раньше было read = false
// Но из-за этого при каждом открытии, даже если файл не изменялся, менялась дата его изменения
var doc = SIDocument.Load(stream);
var docViewModel = new QDocument(doc, _storageContextViewModel)
{
Path = savingPath,
FileName = Path.GetFileNameWithoutExtension(savingPath)
};
if (search != null)
{
docViewModel.SearchText = search;
}
if (overridePath != null)
{
docViewModel.OverridePath = overridePath;
docViewModel.OriginalPath = path;
docViewModel.Changed = true;
}
return(docViewModel);
}
catch (Exception exc)
{
if (stream != null)
{
stream.Dispose();
}
if (exc is FileNotFoundException)
{
AppSettings.Default.History.Remove(path);
}
if (exc is UnauthorizedAccessException && (new FileInfo(path).Attributes & FileAttributes.ReadOnly) > 0)
{
throw new Exception(Resources.FileIsReadOnly);
}
throw exc;
}
});
DocList.Add(new DocumentLoaderViewModel(path, loader, () =>
{
AppSettings.Default.History.Add(savingPath);
onSuccess?.Invoke();
}));
}
public Task <SIDocument> GetPackage(string name)
{
return(Task.FromResult(SIDocument.Load(File.OpenRead(Path.Combine(_folder, name)))));
}
private void SearchInDirectory(DirectoryInfo directoryInfo, string searchText, bool subfoldersSearch, CancellationToken token, int level = 0)
{
var files = directoryInfo.GetFiles("*.siq");
var folders = directoryInfo.GetDirectories();
var total = files.Length + (subfoldersSearch ? folders.Length : 0);
var done = 0;
SearchMatch found = null;
foreach (var file in files)
{
lock (_searchSync)
{
if (token.IsCancellationRequested)
{
return;
}
}
found = null;
try
{
using (var stream = File.OpenRead(file.FullName))
{
using (var doc = SIDocument.Load(stream))
{
var package = doc.Package;
if ((found = package.SearchFragment(searchText)) == null)
{
foreach (var round in package.Rounds)
{
if ((found = round.SearchFragment(searchText)) != null)
{
break;
}
foreach (var theme in round.Themes)
{
if ((found = theme.SearchFragment(searchText)) != null)
{
break;
}
foreach (var quest in theme.Questions)
{
if ((found = quest.SearchFragment(searchText)) != null)
{
break;
}
}
if (found != null)
{
break;
}
}
if (found != null)
{
break;
}
}
}
else
{
}
}
}
if (found != null)
{
var fileNameLocal = file.FullName;
var foundLocal = found;
Task.Factory.StartNew(() =>
{
lock (_searchSync)
{
if (token.IsCancellationRequested)
{
return;
}
SearchResults.Add(new SearchResult
{
FileName = fileNameLocal,
Fragment = foundLocal
});
}
}, CancellationToken.None, TaskCreationOptions.None, UI.Scheduler);
}
}
catch
{
}
finally
{
done++;
if (level == 0)
{
lock (_searchSync)
{
if (!token.IsCancellationRequested)
{
SearchProgress = 100 * done / total;
}
}
}
}
}
if (subfoldersSearch)
{
foreach (var dir in folders)
{
SearchInDirectory(dir, searchText, subfoldersSearch, token, level + 1);
done++;
if (level == 0)
{
lock (_searchSync)
{
if (token.IsCancellationRequested)
{
return;
}
SearchProgress = 100 * done / total;
}
}
}
}
}
/// <summary>
/// Начало игры
/// </summary>
/// <param name="arg"></param>
private async void Start_Executed(object arg)
{
try
{
var packageStream = await _packageSource.GetPackageAsync();
var engineSettingsProvider = new EngineSettingsProvider(SettingsViewModel.Model);
EngineBase engine;
try
{
var document = SIDocument.Load(packageStream);
engine = SettingsViewModel.Model.GameMode == GameModes.Tv ? (EngineBase) new TvEngine(document, engineSettingsProvider) : new SportEngine(document, engineSettingsProvider);
}
catch (Exception exc)
{
throw new Exception(string.Format("Ошибка при загрузке игрового пакета: {0}", exc.Message));
}
var gameHost = PlatformManager.Instance.CreateGameHost(engine);
IRemoteGameUI ui;
if (_isRemoteControlling)
{
if (!Connect(gameHost, out ui))
{
return;
}
}
else
{
ui = new RemoteGameUI {
GameHost = gameHost, ScreenIndex = SettingsViewModel.Model.ScreenNumber
};
ui.UpdateSettings(SettingsViewModel.SIUISettings.Model);
}
var game = new GameEngine(SettingsViewModel, engine, gameHost, ui, Players, _isRemoteControlling);
game.Start();
game.Error += ShowError;
game.RequestStop += Game_RequestStop;
var recent = Settings.Recent;
if (!string.IsNullOrEmpty(_packageSource.Token) && !recent.Contains(_packageSource.Token))
{
recent.Insert(0, _packageSource.Token);
if (recent.Count > 10)
{
recent.RemoveAt(10);
}
}
Mode = GameMode.Moderator;
Game = game;
}
catch (Exception exc)
{
PlatformManager.Instance.ShowMessage(string.Format("Ошибка старта игры: {0}", exc.ToString()), false);
return;
}
}
public Task <SIDocument> GetPackage(string name) => Task.FromResult(SIDocument.Load(Path.Combine(_folder, name)));
