public async void ShowProgress(string location, bool isSvn, string autoInstallName = null)
{
controller = await this.ShowProgressAsync("Updating...", "Downloading the required data.");
controller.SetIndeterminate();
ListAssemblies(location, isSvn, autoInstallName);
}
/// <summary>
/// Runs CanEnable asynchronously multiple times until successful, cancelled or max tries reached
/// </summary>
/// <param name="dialog"></param>
/// <returns></returns>
public Task<bool> CanEnableAsync(ProgressDialogController dialog)
{
return Task.Run(() =>
{
for (var tries = 1; tries <= 10; tries++)
{
// Dialog interaction
if (dialog != null)
{
// Stop if cancelled by user
if (dialog.IsCanceled)
{
dialog.SetIndeterminate();
return false;
}
// Updated progress to indicate how much tries are left
dialog.SetProgress(0.1*tries);
}
if (CanEnable())
{
dialog?.SetIndeterminate();
return true;
}
Thread.Sleep(2000);
}
dialog?.SetIndeterminate();
return false;
});
}
public async void ShowProgress(string location, bool isSvn, string autoInstallName = null)
{
controller =
await
this.ShowProgressAsync(
Utility.GetMultiLanguageText("Updating"), Utility.GetMultiLanguageText("DownloadingData"));
controller.SetIndeterminate();
controller.SetCancelable(true);
ListAssemblies(location, isSvn, autoInstallName);
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
TestRunWorker testRunWorker = (TestRunWorker)faultModel.TestRunWorker;
testRunWorker.Desired = (double)DesiredValueNumUpDown.Value;
testRunWorker.TestCase = TestCaseComboBox.SelectedIndex + 1;
testRunWorker.RunWorkerCompleted += TestRunWorker_RunWorkerCompleted;
progressController = await this.ShowProgressAsync("Please wait...", "Model simulation running");
progressController.SetIndeterminate();
testRunWorker.RunWorkerAsync(faultModel);
log("Allowed Oscillation Fault Model - Ran the model with desired value " + testRunWorker.Desired + " and test case" + testRunWorker.TestCase);
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
TestRunWorker testRunWorker = (TestRunWorker)faultModel.TestRunWorker;
testRunWorker.InitialDesired = (double)InitialValueNumUpDown.Value;
testRunWorker.FinalDesired = (double)FinalValueNumUpDown.Value;
testRunWorker.RunWorkerCompleted += TestRunWorker_RunWorkerCompleted;
progressController = await this.ShowProgressAsync("Please wait...", "Model simulation running");
progressController.SetIndeterminate();
testRunWorker.RunWorkerAsync(faultModel);
log("Step Fault Model - Ran model with initial desired value " + testRunWorker.InitialDesired + " and final desired value " + testRunWorker.FinalDesired);
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
TestRunWorker testRunWorker = (TestRunWorker)faultModel.TestRunWorker;
testRunWorker.Desired = (double)DesiredValueNumUpDown.Value;
testRunWorker.Frequency = (double)FrequencyNumUpDown.Value;
testRunWorker.RunWorkerCompleted += TestRunWorker_RunWorkerCompleted;
progressController = await this.ShowProgressAsync("Please wait...", "Model simulation running");
progressController.SetIndeterminate();
testRunWorker.RunWorkerAsync(faultModel);
log("Disturbance Fault Model - Ran model with desired value " + testRunWorker.Desired + " and frequency " + testRunWorker.Frequency);
}
private async void btnLogin_Click(object sender, RoutedEventArgs e)
{
var email = txtEMail.Text;
var pwd = txtPwd.Password;
if (string.IsNullOrEmpty(email) && string.IsNullOrEmpty(pwd))
{
txtError.Text = "Please enter a EMail and a Password!";
return;
}
else if (string.IsNullOrEmpty(pwd))
{
txtError.Text = "Please enter a Password";
return;
}
else if (string.IsNullOrEmpty(email))
{
txtError.Text = "Please enter a EMail";
return;
}
txtError.Text = "";
IsEnabled = false;
_controller = await this.ShowProgressAsync("Logging in...", "Authenticating...");
_controller.SetIndeterminate();
var result = await Task.Factory.StartNew(() =>
{
return commander.AuthenticateUser(email, pwd);
});
txtPwd.Password = "";
await _controller.CloseAsync();
IsEnabled = true;
if (result == true)
{
await this.ShowMessageAsync("Authenticated", "Login success!");
MainWindow mainWindow = new MainWindow();
mainWindow.Show();
Close();
}
else
{
txtError.Text = "Combination of EMail and Password is incorrect!";
}
_controller.SetProgress(1);
}
private async void PerformanceDay_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (!initialized)
return;
else {
if (PerformanceDay.SelectedItem != null)
{
var selectedItem = (DateTime)PerformanceDay.SelectedItem;
IsEnabled = false;
_controller = await mainWindow.ShowProgressAsync("Performances", "Loading...");
_controller.SetIndeterminate();
await Task.Factory.StartNew(() =>
{
ufoVM.LoadPerformancesOfDay(selectedItem);
});
await _controller.CloseAsync();
IsEnabled = true;
_controller.SetProgress(1);
}
}
}
private async void btnUnsub_Click(object sender, RoutedEventArgs e)
{
if (!eventListViewSubs.Items.Contains(txt_User.Text))
MsgBox("Error", "You are not subscribed to this event!");
else
{
BackgroundWorker bgWorker = new BackgroundWorker() { WorkerReportsProgress = true };
bgWorker.DoWork += (s, ee) =>
{
try
{
Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(async () =>
{
eventUpdating = true;
string eventSelected = this.eventListView.SelectedItem.ToString().Replace(" ", "_");
string encryptedJson = System.IO.File.ReadAllText(workingDir + "\\Config\\" + eventSelected);
string decryptedJson = CryptoService.Load.Decrypt(encryptedJson, softwareCfg.cipherKey);
eventVar _event = JsonConvert.DeserializeObject<eventVar>(decryptedJson);
eventListViewSubs.Items.Remove(txt_User.Text);
List<string> subs = new List<string>();
if (_event.eventSubscribers != null)
{
foreach (string sub in _event.eventSubscribers)
{
subs.Add(sub);
}
}
subs.Remove(txt_User.Text);
_event.eventSubscribers = subs.ToArray();
string eventFileName = eventSelected;
System.IO.File.Delete(workingDir + "\\Config\\" + eventFileName);
Core.Events.MissionFile.Create.File(eventFileName, _event);
Core.Events.MissionFile.Upload.File(eventFileName);
eventUpdating = false;
}));
}
catch (Exception ex)
{ System.Windows.MessageBox.Show(ex.ToString()); }
};
bgWorker.RunWorkerCompleted += async (s, ee) =>
{
pause(5);
await pdC.CloseAsync();
};
bgWorker.RunWorkerAsync();
pdC = await this.ShowProgressAsync("Please wait...", "Unsubscribing to this Event...");
pdC.SetCancelable(false);
pdC.SetIndeterminate();
}
}
private async void updateBtnUs_Click(object sender, RoutedEventArgs e)
{
_controller2 = await this.ShowProgressAsync("Updating...", "Updating the WebConfig File...");
_controller2.SetCancelable(false);
_controller2.SetIndeterminate();
Core.JsonUpdate.Create.File();
Core.JsonUpdate.Upload.File();
pause(5);
await _controller2.CloseAsync();
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
var button = sender as Button;
var buttonCmdParam = button.CommandParameter;
var command = button.Tag as ICommand;
IsEnabled = false;
_controller = await mainWindow.ShowProgressAsync("EMail", "Sending...");
_controller.SetIndeterminate();
await Task.Factory.StartNew(() =>
{
// Execute command in tag
if (button != null)
{
if (command != null)
command.Execute(buttonCmdParam);
}
return true;
});
await _controller.CloseAsync();
IsEnabled = true;
await mainWindow.ShowMessageAsync("EMail", "EMails were sent successfully!");
_controller.SetProgress(1);
}
private async void RunComparisonButton_Click(object sender, RoutedEventArgs e)
{
DataGridHeatPoint runHeatPoint = (DataGridHeatPoint)ExplorationDataGrid.SelectedValue;
TestRunWorker testRunWorker = (TestRunWorker)faultModel.TestRunWorker;
testRunWorker.InitialDesired = runHeatPoint.InitialDesired;
testRunWorker.FinalDesired = runHeatPoint.FinalDesired;
testRunWorker.RunWorkerCompleted += TestRunWorker_RunWorkerCompleted;
testRunWorker.ExecuteOnModel = TestRunWorker.TestModel.Both;
progressController = await this.ShowProgressAsync("Running the model comparison", "Please wait...");
progressController.SetCancelable(false);
progressController.SetIndeterminate();
testRunWorker.RunWorkerAsync(faultModel);
log("Controller Comparison Fault Model - Ran models with initial desired value " + runHeatPoint.InitialDesired + " and final desired value " + runHeatPoint.FinalDesired);
}
private async void UpdateBtn_Click(object sender, RoutedEventArgs e)
{
_controller2 = await this.ShowProgressAsync("Updating...", "Updating the WebConfig File..." );
_controller2.SetCancelable(false);
_controller2.SetIndeterminate();
config.webConfig_News = txt_News.Text;
config.Software = txt_Software.Text;
config.LatestVersion = txt_LatestVersion.Text;
config.Language = txt_Language.Text;
config.notAvailableMsg = txt_notAvailableMsg.Text;
config.MasterIP = txt_MasterIP.Text;
config.MasterIPDNS = txt_MasterIPDNS.Text;
Core.JsonUpdate.Create.File();
Core.JsonUpdate.Upload.File();
pause(5);
await _controller2.CloseAsync();
}
private async void Validate_Click(object sender, RoutedEventArgs e)
{
double modelSimulationTime = (double)this.ModelSimulationTimeNumUpDown.Value;
double desiredValueReachedTime = (double)this.DesiredValueReachedNumUpDown.Value;
double desiredFrom = (double)this.DesiredValueFromNumUpDown.Value;
double desiredTo = (double)this.DesiredValueToNumUpDown.Value;
double actualFrom = (double)this.ActualValueFromNumUpDown.Value;
double actualTo = (double)this.ActualValueToNumUpDown.Value;
double disturbanceAmplitude = (double)this.DisturbanceValueToNumUpDown.Value;
double smoothnessDiff = (double)this.SmoothnessStartDifferenceNumUpDown.Value;
double responsivenessClose = (double)this.ResponsivenessCloseNumUpDown.Value;
if (desiredValueReachedTime >= modelSimulationTime)
{
MessageBox.Show("Invalid desired value reached time. The desired value reached time cannot be greater or equal to the model simulation time.", "Invalid setting", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (desiredFrom >= desiredTo)
{
MessageBox.Show("Invalid desired value range", "Invalid setting", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (actualFrom >= actualTo)
{
MessageBox.Show("Invalid actual value range", "Invalid setting", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (actualFrom > desiredFrom)
{
MessageBox.Show("Invalid actual value range", "Invalid setting", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (smoothnessDiff > (Math.Abs(actualFrom - actualTo)/10))
{
MessageBox.Show("The value after which the smoothness measurement begins cannot be more than a tenth of the actual value range.", "Invalid setting", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (responsivenessClose > (Math.Abs(actualFrom - actualTo) / 20))
{
MessageBox.Show("The absolute difference between the actual and the desired value at which the responsiveness measurement ends cannot be more than a fifth of the actual value range.", "Invalid setting", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (String.IsNullOrWhiteSpace(this.DesiredValueNameTextBox.Text))
{
MessageBox.Show("Please specify the name of the desired variable.", "Invalid setting", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (String.IsNullOrWhiteSpace(this.ActualValueNameTextBox.Text))
{
MessageBox.Show("Please specify the name of the actual variable.", "Invalid setting", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (this.RefinedCandidatePointsNumUpDown.Value > 10)
{
MessageBox.Show("A maximum of 10 candidate points are allowed.", "Invalid setting", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
SimulationParameter desired = new SimulationParameter(this.DesiredValueNameTextBox.Text, SimulationParameterType.Desired, new decimal(desiredFrom), new decimal(desiredTo));
SimulationParameter actual = new SimulationParameter(this.ActualValueNameTextBox.Text, SimulationParameterType.Actual, new decimal(actualFrom), new decimal(actualTo));
SimulationParameter disturbance = new SimulationParameter(this.DisturbanceValueNameTextBox.Text, SimulationParameterType.Disturbance, new decimal(0), new decimal(disturbanceAmplitude));
ModelRegressionSettings regressionSettings = new ModelRegressionSettings() { ModelQuality = (double)this.ModelQualityNumUpDown.Value, RefinedCandidatePoints = (int)this.RefinedCandidatePointsNumUpDown.Value, RefinementPoints = (int)this.RefinementSizeNumUpDown.Value, ValidationSetSize = (int)this.ValidationSetRandomPointsNumUpDown.Value, TrainingSetSizeEqualDistance = (int)this.TrainingSetPointsNumUpDown.Value, TrainingSetSizeRandom = (int)this.TrainingSetRandomPointsNumUpDown.Value };
ModelSimulationSettings = new SimulationSettings(modelSimulationTime, desiredValueReachedTime, smoothnessDiff, responsivenessClose, desired, actual, disturbance, regressionSettings);
progressController = await containingWindow.ShowProgressAsync("Please wait...", "Model compilation and simulation running");
progressController.SetIndeterminate();
TestFunctionality();
}
private async void RunTestCase(AllowedOscillationInternalTestCase internalTestCase)
{
TestRunWorker testRunWorker = (TestRunWorker)faultModel.TestRunWorker;
testRunWorker.Desired = internalTestCase.InitialDesired;
testRunWorker.TestCase = internalTestCase.TestCaseIndex;
testRunWorker.RunWorkerCompleted += TestRunWorker_RunWorkerCompleted;
progressController = await this.ShowProgressAsync("Running the model", "Please wait...");
progressController.SetCancelable(false);
progressController.SetIndeterminate();
testRunWorker.RunWorkerAsync(faultModel);
log("Allowed Oscillation Fault Model - Ran model with initial desired value " + internalTestCase.InitialDesired + ", test case " + internalTestCase.TestCaseIndex);
}
private async void DownloadSelectedLanguageSubtitles( )
{
if ( LanguageList.SelectedItems.Count <= 0 )
return;
controller = await window.ShowProgressAsync( "Downloading subtitles", "Downloading subtitles for the selected languages from opensubtitles.org." );
controller.SetIndeterminate( );
string[ ] languages = new string[ LanguageList.SelectedItems.Count ];
for ( int x = 0; x < languages.Length; ++x )
languages[ x ] = ( ( SubtitleLanguage ) LanguageList.SelectedItems[ x ] ).ISO639_3;
SubtitleData[ ] data = await Task.Run( ( ) => MainWindow.Client.SearchSubtitles( languages, MainWindow.Player.GetComponent<MediaComponent>( ).Media.File ) );
SubsGroupBox.Visibility = Visibility.Visible;
this.SubtitlesList.ItemsSource = data;
CollectionView subsView = ( CollectionView ) CollectionViewSource.GetDefaultView( SubtitlesList.ItemsSource );
subsView.SortDescriptions.Add( new SortDescription( "DownloadsCount", ListSortDirection.Descending ) );
Scroller.ScrollToBottom( );
await controller.CloseAsync( );
}
private async void OnFlyoutFirstOpen( )
{
if ( MainWindow.Client.IsLoggedIn ) return;
controller = await window.ShowProgressAsync( "Signing in.", "Signing into opensubtitles.org." );
controller.SetIndeterminate( );
LogInOutput output = await SignInClient( );
if ( output.LogInSuccesful && MainWindow.Client.IsLoggedIn )
{
controller.SetTitle( "Downloading subtitle languages." );
controller.SetMessage( "Downloading the available subtitle languages from opensubtitles.org." );
this.languages = await GetSubtitleLanguages( );
this.LanguageList.ItemsSource = this.languages;
CollectionView languagesView = ( CollectionView )CollectionViewSource.GetDefaultView( LanguageList.ItemsSource );
languagesView.SortDescriptions.Add( new SortDescription( "LanguageName", ListSortDirection.Ascending ) );
}
else
await window.ShowMessageAsync( "Signing in failed", $"Unable to sign in to opensubtitles.org. Please try again later. (Status: {output.Status}, {output.StatusStringWithoutCode})" );
await controller.CloseAsync( );
OnFlyoutOpen( );
}
private async void eventMod_Click(object sender, RoutedEventArgs e)
{
if (!config.Administrators.Contains(txt_User.Text))
{
MsgBox("Error", "You MUST be and Administrator to complete this action!");
return;
}
if (string.IsNullOrEmpty(txtmissionNameMod.Text) ||
string.IsNullOrEmpty(comboMapMod.SelectedItem.ToString()) ||
string.IsNullOrEmpty(Convert.ToString(nudPlayersMod.Value)) ||
string.IsNullOrEmpty(txtmissionDescriptionMod.Text))
{
MsgBox("Error", "Please compile all field before create the event!");
return;
}
BackgroundWorker bgWorker = new BackgroundWorker() { WorkerReportsProgress = true };
bgWorker.DoWork += (s, ee) =>
{
try
{
Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(async () =>
{
_eventVar = new eventVar();
List<string> _modList = new List<string>();
foreach (string item in modListMod.SelectedItems)
{
_modList.Add(item);
}
_eventVar.eventName = txtmissionNameMod.Text;
_eventVar.eventDate = Convert.ToDateTime(eventCalendarMod.SelectedDate);
_eventVar.eventMap = comboMapMod.SelectedItem.ToString();
_eventVar.eventType = comboTypeMod.SelectedItem.ToString();
_eventVar.eventMinPlayers = Convert.ToInt16(nudPlayersMod.Value);
_eventVar.eventDescription = txtmissionDescriptionMod.Text;
_eventVar.eventMods = _modList.ToArray();
List<string> subs = new List<string>();
string[] _subs = null;
foreach (string sub in eventListViewSubs.Items)
{
subs.Add(sub);
}
_subs = subs.ToArray();
_eventVar.eventSubscribers = _subs;
string eventFileName = txtmissionNameMod.Text.Replace(" ", "_") + "_" + Convert.ToString(_eventVar.eventDate).Replace(" 00:00:00", "").Replace("/", "-") + "_" + _eventVar.eventMap;
if (System.IO.File.Exists(workingDir + "\\Config\\" + _eventFileName))
{
System.IO.File.Delete(workingDir + "\\Config\\" + _eventFileName);
}
Core.Events.MissionFile.Create.File(eventFileName, _eventVar);
Core.Events.MissionFile.Upload.File(eventFileName);
List<string> eventsList = new List<string>();
if (config.events != null)
{
foreach (string item in config.events)
{
eventsList.Add(item);
}
if (config.events.Contains(_eventFileName))
{
eventsList.Remove(_eventFileName);
}
}
eventsList.Add(eventFileName);
config.events = eventsList.ToArray();
Core.JsonUpdate.Create.File();
Core.JsonUpdate.Upload.File();
}));
}
catch (Exception ex)
{ System.Windows.MessageBox.Show(ex.ToString()); }
};
bgWorker.RunWorkerCompleted += async (s, ee) =>
{
pause(5);
await _controller.CloseAsync();
eventUpdating = true;
this.eventListView.Items.Clear();
this.eventListView.Items.Refresh();
eventloadBase();
eventUpdating = false;
};
bgWorker.RunWorkerAsync();
_controller = await this.ShowProgressAsync("Please wait...", "Creating Online Event...");
_controller.SetCancelable(false);
_controller.SetIndeterminate();
}
private async void RunButton_Click(object sender, RoutedEventArgs e)
{
(sender as Button).GetValue(DataGridRow.AlternationIndexProperty);
DataGridHeatPoint runHeatPoint = (DataGridHeatPoint)ExplorationDataGrid.SelectedValue;
TestRunWorker testRunWorker = (TestRunWorker)faultModel.TestRunWorker;
testRunWorker.Desired = runHeatPoint.Desired;
testRunWorker.DisturbanceStartTime = runHeatPoint.Time;
testRunWorker.RunWorkerCompleted += TestRunWorker_RunWorkerCompleted;
progressController = await this.ShowProgressAsync("Running the model", "Please wait...");
progressController.SetCancelable(false);
progressController.SetIndeterminate();
testRunWorker.RunWorkerAsync(faultModel);
log("Disturbance Fault Model - Ran model with desired value " + runHeatPoint.Desired + " and disturbance start time " + runHeatPoint.Time);
}
async void jsonwb_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
{
_9GUSLauncher.MainWindow.config = JsonConvert.DeserializeObject<Config.Config>(e.Result);
pause(1);
StandardLog("SoftwareID " + Convert.ToString(config.SoftwareID) + " authenticated");
mainForm.Title += " - ID " + Convert.ToString(config.SoftwareID);
//Check for Updates
StandardLog("Checking for Updates...");
CheckForUpdates();
//Create Update dir
if (!Directory.Exists(workingDir + "\\Update"))
{
Directory.CreateDirectory(workingDir + "\\Update");
}
else
{
Directory.Delete(workingDir + "\\Update", true);
Directory.CreateDirectory(workingDir + "\\Update");
}
WebClient wb = new WebClient();
if (result > 0)
{
try
{
StandardLog("Version " + config.LatestVersion + " is available. Downloading...");
_controller = await this.ShowProgressAsync("Please wait...", "Downloading the update " + config.LatestVersion);
_controller.SetCancelable(false);
_controller.SetIndeterminate();
wb.DownloadFileAsync(new Uri(softwareCfg.updateFile), workingDir + "\\Update\\9GUSLauncher.exe");
wb.DownloadProgressChanged += new DownloadProgressChangedEventHandler(downloadProgress);
wb.DownloadFileCompleted += new AsyncCompletedEventHandler(completedDownload);
}
catch (Exception ex) { System.Windows.Forms.MessageBox.Show(ex.ToString()); }
}
else if (result < 0)
{
StandardLog("You are running a Beta Version. No Updates will be done."); // the update system isn't in the freeze problem
//No Update, version is more than latest
}
else
{
StandardLog("Version Stable. No Updates needed.");
//Version Stable
LeftToRightMarquee();
login_button.IsEnabled = true;
}
}
private async void btnExportAll_Click(object sender, RoutedEventArgs e)
{
var folderDialog = new CommonOpenFileDialog();
folderDialog.Title = "Where should I save your data?";
folderDialog.IsFolderPicker = true;
folderDialog.EnsureFileExists = true;
folderDialog.EnsurePathExists = true;
folderDialog.EnsureValidNames = true;
folderDialog.EnsureReadOnly = false;
folderDialog.Multiselect = false;
folderDialog.ShowPlacesList = true;
if (folderDialog.ShowDialog() == CommonFileDialogResult.Ok)
{
Telemetry.TrackEvent(TelemetryCategory.Export, Telemetry.TelemetryEvent.Export.Full);
var folder = folderDialog.FileName;
BandCloudManager.Instance.Events.Clear();
_fullExportProgressDialog = await ((MetroWindow)(Window.GetWindow(this))).ShowProgressAsync("Exporting Full Activity Data", "Loading Activities list...");
_fullExportProgressDialog.SetCancelable(true); // TODO: this needs to be implemented. No event?
_fullExportProgressDialog.SetIndeterminate();
// HACK HACK HACK HACK
// TODO: add a Cancelled Event into the MahApps.Metro library
// polling method to cancel the export if the user requests that it be cancelled
Task.Run(async () =>
{
while (_fullExportProgressDialog != null && _fullExportProgressDialog.IsOpen)
{
if (_fullExportProgressDialog.IsCanceled)
{
BandCloudManager.Instance.CancelFullExport = true;
Telemetry.TrackEvent(TelemetryCategory.Export, Telemetry.TelemetryEvent.Export.FullCancelled);
// we'd exit from the while loop anyway, but only when the progress dialog finally exits
// which can take up to 10 seconds, so might as well shut this down asap
return;
}
await Task.Delay(500);
}
});
await LoadEvents();
var progressIndicator = new Progress<BandCloudExportProgress>(ReportFullExportProgress);
// TODO: progress reporter
await BandCloudManager.Instance.ExportFullEventData(folder, ExportSettings, progressIndicator);
_fullExportProgressDialog.CloseAsync();
SaveExportSettings();
}
}
public ProgressStatistics( ProgressDialogController controller )
{
Controller = controller;
Controller.SetIndeterminate();
}
public async Task LoadTheGameDbGame()
{
await Task.Factory.StartNew(async () =>
{
GiochiCaricati = string.Empty;
await App.Current.Dispatcher.BeginInvoke((Action)async delegate ()
{
progressDialog = await _dialogCoordinator.ShowProgressAsync(this, "Attendi...", "Attendi mentre carico la lista dei giochi", false, new MetroDialogSettings()
{
ColorScheme = MetroDialogColorScheme.Accented
});
progressDialog.SetIndeterminate();
});
IsReadOnlyTitleSearch = true;
if (GamesDto.Count > 0)
GamesDto.Clear();
List<GameSummary> gs = new List<GameSummary>();
if (CurrentPlatform.Name != "Tutti")
gs = await _currentWebApi.TheGamesDBGameListByPlatform(DataInizio, DataFine, CurrentPlatform);
else
AvailablePlatforms.Where(x => x.Name != "Tutti").ToList().ForEach(async _currentPlatform =>
{
gs.AddRange(await _currentWebApi.TheGamesDBGameListByPlatform(DataInizio, DataFine, _currentPlatform));
});
await App.Current.Dispatcher.BeginInvoke((Action)async delegate ()
{
await progressDialog.CloseAsync();
});
int numGiochi = gs.Count;
int giocoCorrente = 0;
double percentageToIncrement = (double)100 / numGiochi;
ProgressBarValue = 0;
gs.ForEach(async currentGameSummary =>
{
try
{
if (await _currentWebApi.GetGameByFieldSearch(new Game() { ImportId = currentGameSummary.ID }) == default(Game))
{
GameDto result = _mapper.Map<GameDto>(await _currentWebApi.TheGamesDBGetGameDetails(currentGameSummary));
await App.Current.Dispatcher.BeginInvoke((Action)delegate ()
{
GamesDto.Add(result);
});
}
}
catch (Exception ex)
{
numGiochi--;
giocoCorrente--;
string a = ex.Message;
}
finally
{
giocoCorrente++;
GiochiCaricati = string.Format("{0} / {1}", giocoCorrente, numGiochi);
ProgressBarValue += percentageToIncrement;
if (numGiochi == giocoCorrente)
{
await App.Current.Dispatcher.BeginInvoke((Action)async delegate ()
{
await _dialogCoordinator.ShowMessageAsync(this, "Caricamento completato...", "Puoi modificare i giochi prima dell'importazione", MessageDialogStyle.Affirmative, new MetroDialogSettings()
{
ColorScheme = MetroDialogColorScheme.Accented
});
});
IsReadOnlyTitleSearch = false;
}
}
});
});
}