private async void BtnWeb_Click(object sender, RoutedEventArgs e)
{
var deck = await ImportDeckFromWeb();
if (deck != null)
{
var reimport = EditingDeck && _newDeck != null &&
_newDeck.Url == deck.Url;
if (reimport) //keep old notes
{
deck.Note = _newDeck.Note;
}
if (!deck.Note.Contains(deck.Url))
{
deck.Note = deck.Url + "\n" + deck.Note;
}
SetNewDeck(deck, reimport);
TagControlEdit.SetSelectedTags(deck.Tags);
}
else
{
await this.ShowMessageAsync("Error", "Could not load deck from specified url");
}
}
public async void ImportDeck(string url = null)
{
if (url == null)
{
url = await InputDeckURL();
}
if (url == null)
{
return;
}
var deck = await ImportDeckFromURL(url);
if (deck != null)
{
var reimport = EditingDeck && _newDeck != null && _newDeck.Url == deck.Url;
if (reimport) //keep old notes
{
deck.Note = _newDeck.Note;
}
SetNewDeck(deck, reimport);
TagControlEdit.SetSelectedTags(deck.Tags);
if (Config.Instance.AutoSaveOnImport)
{
SaveDeckWithOverwriteCheck();
}
}
else
{
await this.ShowMessageAsync("Error", "Could not load deck from specified url");
}
}
private void BtnFile_Click(object sender, RoutedEventArgs e)
{
var dialog = new OpenFileDialog {Title = "Select Deck File", DefaultExt = "*.xml;*.txt", Filter = "Deck Files|*.txt;*.xml"};
var dialogResult = dialog.ShowDialog();
if(dialogResult == true)
{
try
{
Deck deck = null;
if(dialog.FileName.EndsWith(".txt"))
{
using(var sr = new StreamReader(dialog.FileName))
deck = ParseCardString(sr.ReadToEnd());
}
else if(dialog.FileName.EndsWith(".xml"))
{
deck = XmlManager<Deck>.Load(dialog.FileName);
//not all required information is saved in xml
foreach(var card in deck.Cards)
card.Load();
TagControlEdit.SetSelectedTags(deck.Tags);
}
SetNewDeck(deck);
if(Config.Instance.AutoSaveOnImport)
SaveDeckWithOverwriteCheck();
}
catch(Exception ex)
{
Logger.WriteLine("Error getting deck from file: \n" + ex, "Import");
}
}
}
public async void ImportDeck(string url = null)
{
var result = await ImportDeckFromUrl(url);
if (result.WasCancelled)
{
return;
}
if (result.Deck != null)
{
var reimport = EditingDeck && _newDeck != null && _newDeck.Url == result.Deck.Url;
if (reimport) //keep old notes
{
result.Deck.Note = _newDeck.Note;
}
SetNewDeck(result.Deck, reimport);
TagControlEdit.SetSelectedTags(result.Deck.Tags);
if (Config.Instance.AutoSaveOnImport)
{
SaveDeckWithOverwriteCheck();
}
}
else
{
await this.ShowMessageAsync("No deck found", "Could not find a deck on" + Environment.NewLine + result.Url);
}
}
private async void BtnWeb_Click(object sender, RoutedEventArgs e)
{
var url = await InputDeckURL();
if (url == null)
{
return;
}
var deck = await ImportDeckFromURL(url);
if (deck != null)
{
var reimport = EditingDeck && _newDeck != null && _newDeck.Url == deck.Url;
if (reimport) //keep old notes
{
deck.Note = _newDeck.Note;
}
SetNewDeck(deck, reimport);
TagControlEdit.SetSelectedTags(deck.Tags);
if (Config.Instance.AutoSaveOnImport)
{
await SaveDeckWithOverwriteCheck();
}
}
else
{
await this.ShowMessageAsync("Error", "Could not load deck from specified url");
}
}
private void DeckPickerList_OnSelectedDeckChanged(DeckPicker sender, Deck deck)
{
if (deck != null)
{
//set up notes
DeckNotesEditor.SetDeck(deck);
var flyoutHeader = deck.Name.Length >= 20 ? string.Join("", deck.Name.Take(17)) + "..." : deck.Name;
FlyoutNotes.Header = flyoutHeader;
if (Config.Instance.StatsInWindow)
{
StatsWindow.Title = "Stats: " + deck.Name;
StatsWindow.StatsControl.SetDeck(deck);
}
else
{
FlyoutDeckStats.Header = "Stats: " + deck.Name;
DeckStatsFlyout.SetDeck(deck);
}
//change player deck itemsource
if (Overlay.ListViewPlayer.ItemsSource != Game.PlayerDeck)
{
Overlay.ListViewPlayer.ItemsSource = Game.PlayerDeck;
PlayerWindow.ListViewPlayer.ItemsSource = Game.PlayerDeck;
Logger.WriteLine("Set player itemsource as playerdeck");
}
Game.IsUsingPremade = true;
UpdateDeckList(deck);
UseDeck(deck);
Logger.WriteLine("Switched to deck: " + deck.Name);
//set and save last used deck for class
while (DeckList.LastDeckClass.Any(ldc => ldc.Class == deck.Class))
{
var lastSelected = DeckList.LastDeckClass.FirstOrDefault(ldc => ldc.Class == deck.Class);
if (lastSelected != null)
{
DeckList.LastDeckClass.Remove(lastSelected);
}
else
{
break;
}
}
DeckList.LastDeckClass.Add(new DeckInfo {
Class = deck.Class, Name = deck.Name
});
WriteDecks();
EnableMenuItems(true);
ManaCurveMyDecks.SetDeck(deck);
TagControlEdit.SetSelectedTags(deck.Tags);
MenuItemQuickSetTag.ItemsSource = TagControlEdit.Tags;
MenuItemQuickSetTag.Items.Refresh();
MenuItemUpdateDeck.IsEnabled = !string.IsNullOrEmpty(deck.Url);
}
else
{
EnableMenuItems(false);
}
}
private void BtnTags_Click(object sender, RoutedEventArgs e)
{
FlyoutMyDecksSetTags.IsOpen = true;
if (DeckPickerList.SelectedDeck != null)
{
TagControlEdit.SetSelectedTags(DeckPickerList.SelectedDeck.Tags);
}
}
internal void ShowTagEditDialog(IEnumerable <Deck> decks)
{
if (decks == null || !decks.Any())
{
return;
}
FlyoutMyDecksSetTags.IsOpen = true;
TagControlEdit.SetSelectedTags(decks);
}
internal void ImportFromFile()
{
var dialog = new OpenFileDialog {
Title = "Select Deck File", DefaultExt = "*.xml;*.txt", Filter = "Deck Files|*.txt;*.xml"
};
dialog.Multiselect = true;
var dialogResult = dialog.ShowDialog();
if (dialogResult == true)
{
foreach (var file in dialog.FileNames)
{
try
{
Deck deck = null;
if (file.EndsWith(".txt"))
{
using (var sr = new StreamReader(file))
deck = StringImporter.Import(sr.ReadToEnd());
}
else if (file.EndsWith(".xml"))
{
deck = XmlManager <Deck> .Load(file);
//not all required information is saved in xml
foreach (var card in deck.Cards)
{
card.Load();
}
TagControlEdit.SetSelectedTags(deck.Tags);
}
if (Config.Instance.AutoSaveOnImport || dialog.FileNames.Length > 1)
{
DeckManager.SaveDeck(deck);
}
else
{
ShowDeckEditorFlyout(deck, true);
}
}
catch (Exception ex)
{
Log.Error(ex);
}
}
}
}
private void SaveImportedDeck(Deck deck)
{
var reimport = EditingDeck && _newDeck != null && _newDeck.Url == deck.Url;
if (reimport) //keep old notes
{
deck.Note = _newDeck.Note;
}
SetNewDeck(deck, reimport);
TagControlEdit.SetSelectedTags(deck.Tags);
if (Config.Instance.AutoSaveOnImport)
{
SaveDeckWithOverwriteCheck();
}
}
private void BtnFile_Click(object sender, RoutedEventArgs e)
{
var dialog = new OpenFileDialog {
Title = "Select Deck File", DefaultExt = "*.xml;*.txt", Filter = "Deck Files|*.txt;*.xml"
};
dialog.Multiselect = true;
var dialogResult = dialog.ShowDialog();
if (dialogResult == true)
{
foreach (String file in dialog.FileNames)
{
try
{
Deck deck = null;
if (file.EndsWith(".txt"))
{
using (var sr = new StreamReader(file))
deck = Helper.ParseCardString(sr.ReadToEnd());
}
else if (file.EndsWith(".xml"))
{
deck = XmlManager <Deck> .Load(file);
//not all required information is saved in xml
foreach (var card in deck.Cards)
{
card.Load();
}
TagControlEdit.SetSelectedTags(deck.Tags);
}
SetNewDeck(deck);
if (Config.Instance.AutoSaveOnImport || dialog.FileNames.Length > 1)
{
SaveDeckWithOverwriteCheck();
}
}
catch (Exception ex)
{
Log.Error(ex);
}
}
}
}
internal async void BtnUpdateDeck_Click(object sender, RoutedEventArgs e)
{
var selectedDeck = DeckPickerList.SelectedDecks.FirstOrDefault();
if (selectedDeck == null || string.IsNullOrEmpty(selectedDeck.Url))
{
return;
}
var deck = await DeckImporter.Import(selectedDeck.Url);
if (deck == null)
{
await this.ShowMessageAsync("Error", "Could not load deck from specified url.");
return;
}
//this could be expanded to check against the last version of the deck that was not modified after downloading
if (deck.Cards.All(c1 => selectedDeck.GetSelectedDeckVersion().Cards.Any(c2 => c1.Name == c2.Name && c1.Count == c2.Count)))
{
await this.ShowMessageAsync("Already up to date.", "No changes found.");
return;
}
SetNewDeck(selectedDeck, true);
TextBoxDeckName.Text = deck.Name;
_newDeck.Cards.Clear();
foreach (var card in deck.Cards)
{
_newDeck.Cards.Add(card);
}
_newDeck.Edited();
UpdateCardCount();
Helper.SortCardCollection(ListViewDeck.Items, Config.Instance.CardSortingClassFirst);
ManaCurveMyDecks.UpdateValues();
TagControlEdit.SetSelectedTags(deck.Tags);
}
private async void BtnUpdateDeck_Click(object sender, RoutedEventArgs e)
{
var selectedDeck = DeckPickerList.SelectedDeck;
if (selectedDeck == null || string.IsNullOrEmpty(selectedDeck.Url))
{
return;
}
var deck = await DeckImporter.Import(selectedDeck.Url);
if (deck == null)
{
await this.ShowMessageAsync("Error", "Could not load deck from specified url.");
return;
}
if (deck.Cards.All(c1 => selectedDeck.Cards.Any(c2 => c1.Name == c2.Name && c1.Count == c2.Count)))
{
await this.ShowMessageAsync("Already up to date.", "No changes found.");
return;
}
SetNewDeck(selectedDeck, true);
TextBoxDeckName.Text = deck.Name;
_newDeck.Cards.Clear();
foreach (var card in deck.Cards)
{
_newDeck.Cards.Add(card);
}
UpdateTitle();
Helper.SortCardCollection(ListViewDeck.Items, Config.Instance.CardSortingClassFirst);
ManaCurveMyDecks.UpdateValues();
TagControlEdit.SetSelectedTags(deck.Tags);
}
internal async void UpdateDeckFromWeb(Deck existingDeck)
{
if (existingDeck == null || string.IsNullOrEmpty(existingDeck.Url))
{
return;
}
var deck = await DeckImporter.Import(existingDeck.Url);
if (deck == null)
{
await this.ShowMessageAsync("Error", "Could not load deck from specified url.");
return;
}
//this could be expanded to check against the last version of the deck that was not modified after downloading
if (deck.Cards.All(c1 => existingDeck.GetSelectedDeckVersion().Cards.Any(c2 => c1.Name == c2.Name && c1.Count == c2.Count)) && deck.Name == existingDeck.Name)
{
await this.ShowMessageAsync("Already up to date.", "No changes found.");
return;
}
var imported = (Deck)existingDeck.Clone();
imported.Name = deck.Name;
imported.Cards.Clear();
foreach (var card in deck.Cards)
{
imported.Cards.Add(card);
}
ShowDeckEditorFlyout(imported, false);
Helper.SortCardCollection(ListViewDeck.Items, Config.Instance.CardSortingClassFirst);
ManaCurveMyDecks.UpdateValues();
TagControlEdit.SetSelectedTags(deck.Tags);
}
public void SelectDeck(Deck deck, bool setActive)
{
if (DeckList.Instance.ActiveDeck != null)
{
DeckPickerList.ClearFromCache(DeckList.Instance.ActiveDeck);
}
if (deck != null)
{
//set up tags
TagControlEdit.SetSelectedTags(DeckPickerList.SelectedDecks);
DeckPickerList.MenuItemQuickSetTag.ItemsSource = TagControlEdit.Tags;
DeckPickerList.MenuItemQuickSetTag.Items.Refresh();
OnPropertyChanged(nameof(HsReplayButtonVisibility));
//set and save last used deck for class
if (setActive)
{
while (DeckList.Instance.LastDeckClass.Any(ldc => ldc.Class == deck.Class))
{
var lastSelected = DeckList.Instance.LastDeckClass.FirstOrDefault(ldc => ldc.Class == deck.Class);
if (lastSelected != null)
{
DeckList.Instance.LastDeckClass.Remove(lastSelected);
}
else
{
break;
}
}
if (Core.Initialized)
{
DeckList.Instance.LastDeckClass.Add(new DeckInfo {
Class = deck.Class, Name = deck.Name, Id = deck.DeckId
});
DeckList.Save();
}
Log.Info($"Switched to deck: {deck.Name} ({deck.SelectedVersion.ShortVersionString})");
Core.TrayIcon.MenuItemUseNoDeck.Checked = false;
}
if (FlyoutDeckScreenshot.IsOpen)
{
DeckScreenshotFlyout.Deck = deck.GetSelectedDeckVersion();
}
if (FlyoutDeckExport.IsOpen)
{
DeckExportFlyout.Deck = deck.GetSelectedDeckVersion();
}
if (FlyoutDeckHistory.IsOpen)
{
if (deck.HasVersions)
{
DeckHistoryFlyout.Deck = deck;
}
else
{
FlyoutDeckHistory.IsOpen = false;
}
}
}
else
{
Core.Game.IsUsingPremade = false;
if (DeckList.Instance.ActiveDeck != null)
{
DeckList.Instance.ActiveDeck.IsSelectedInGui = false;
}
DeckList.Instance.ActiveDeck = null;
if (setActive)
{
DeckPickerList.DeselectDeck();
}
Core.TrayIcon.MenuItemUseNoDeck.Checked = true;
}
if (setActive)
{
UseDeck(deck);
}
DeckPickerList.SelectDeck(deck);
UpdateDeckList(deck);
ManaCurveMyDecks.SetDeck(deck);
UpdatePanelVersionComboBox(deck);
GroupBoxHsReplayDeckInfo.Visibility = deck?.IsArenaDeck == true ? Collapsed : Visible;
if (setActive)
{
Core.Overlay.ListViewPlayer.Items.Refresh();
Core.Windows.PlayerWindow.ListViewPlayer.Items.Refresh();
}
DeckManagerEvents.OnDeckSelected.Execute(deck);
}
public void SelectDeck(Deck deck, bool setActive)
{
if (DeckList.Instance.ActiveDeck != null)
{
DeckPickerList.ClearFromCache(DeckList.Instance.ActiveDeck);
}
if (deck != null)
{
//set up notes
DeckNotesEditor.SetDeck(deck);
var flyoutHeader = deck.Name.Length >= 20 ? string.Join("", deck.Name.Take(17)) + "..." : deck.Name;
FlyoutNotes.Header = flyoutHeader;
//set up tags
TagControlEdit.SetSelectedTags(DeckPickerList.SelectedDecks);
MenuItemQuickSetTag.ItemsSource = TagControlEdit.Tags;
MenuItemQuickSetTag.Items.Refresh();
DeckPickerList.MenuItemQuickSetTag.ItemsSource = TagControlEdit.Tags;
DeckPickerList.MenuItemQuickSetTag.Items.Refresh();
//set and save last used deck for class
if (setActive)
{
while (DeckList.Instance.LastDeckClass.Any(ldc => ldc.Class == deck.Class))
{
var lastSelected = DeckList.Instance.LastDeckClass.FirstOrDefault(ldc => ldc.Class == deck.Class);
if (lastSelected != null)
{
DeckList.Instance.LastDeckClass.Remove(lastSelected);
}
else
{
break;
}
}
if (Core.Initialized)
{
DeckList.Instance.LastDeckClass.Add(new DeckInfo {
Class = deck.Class, Name = deck.Name, Id = deck.DeckId
});
DeckList.Save();
}
Log.Info("Switched to deck: " + deck.Name);
int useNoDeckMenuItem = Core.TrayIcon.NotifyIcon.ContextMenu.MenuItems.IndexOfKey(TrayIcon.UseNoDeckMenuItemName);
Core.TrayIcon.NotifyIcon.ContextMenu.MenuItems[useNoDeckMenuItem].Checked = false;
}
}
else
{
Core.Game.IsUsingPremade = false;
if (DeckList.Instance.ActiveDeck != null)
{
DeckList.Instance.ActiveDeck.IsSelectedInGui = false;
}
DeckList.Instance.ActiveDeck = null;
if (setActive)
{
DeckPickerList.DeselectDeck();
}
var useNoDeckMenuItem = Core.TrayIcon.NotifyIcon.ContextMenu.MenuItems.IndexOfKey(TrayIcon.UseNoDeckMenuItemName);
Core.TrayIcon.NotifyIcon.ContextMenu.MenuItems[useNoDeckMenuItem].Checked = true;
}
if (setActive)
{
UseDeck(deck);
}
DeckPickerList.SelectDeck(deck);
UpdateDeckList(deck);
EnableMenuItems(deck != null);
ManaCurveMyDecks.SetDeck(deck);
UpdatePanelVersionComboBox(deck);
if (setActive)
{
Core.Overlay.ListViewPlayer.Items.Refresh();
Core.Windows.PlayerWindow.ListViewPlayer.Items.Refresh();
}
DeckManagerEvents.OnDeckSelected.Execute(deck);
}
private async void SaveDeck(bool overwrite)
{
var deckName = TextBoxDeckName.Text;
if (string.IsNullOrEmpty(deckName))
{
var settings = new MetroDialogSettings {
AffirmativeButtonText = "Set", DefaultText = deckName
};
var name = await this.ShowInputAsync("No name set", "Please set a name for the deck", settings);
if (String.IsNullOrEmpty(name))
{
return;
}
deckName = name;
TextBoxDeckName.Text = name;
}
while (DeckList.DecksList.Any(d => d.Name == deckName) && (!EditingDeck || !overwrite))
{
var settings = new MetroDialogSettings {
AffirmativeButtonText = "Set", DefaultText = deckName
};
var name =
await
this.ShowInputAsync("Name already exists", "You already have a deck with that name, please select a different one.", settings);
if (String.IsNullOrEmpty(name))
{
return;
}
deckName = name;
TextBoxDeckName.Text = name;
}
if (_newDeck.Cards.Sum(c => c.Count) != 30)
{
var settings = new MetroDialogSettings {
AffirmativeButtonText = "Yes", NegativeButtonText = "No"
};
var result =
await
this.ShowMessageAsync("Not 30 cards",
string.Format("Deck contains {0} cards. Is this what you want to save anyway?",
_newDeck.Cards.Sum(c => c.Count)),
MessageDialogStyle.AffirmativeAndNegative, settings);
if (result != MessageDialogResult.Affirmative)
{
return;
}
}
if (EditingDeck && overwrite)
{
DeckList.DecksList.Remove(_newDeck);
DeckPickerList.RemoveDeck(_newDeck);
}
var oldDeckName = _newDeck.Name;
_newDeck.Name = deckName;
_newDeck.Tags = TagControlEdit.GetTags();
var newDeckClone = (Deck)_newDeck.Clone();
DeckList.DecksList.Add(newDeckClone);
newDeckClone.LastEdited = DateTime.Now;
WriteDecks();
Logger.WriteLine("Saved Decks");
if (EditingDeck)
{
TagControlEdit.SetSelectedTags(new List <string>());
if (deckName != oldDeckName)
{
var statsEntry = DeckStatsList.Instance.DeckStats.FirstOrDefault(d => d.Name == oldDeckName);
if (statsEntry != null)
{
if (overwrite)
{
statsEntry.Name = deckName;
Logger.WriteLine("Deck has new name, updated deckstats");
}
else
{
var newStatsEntry = DeckStatsList.Instance.DeckStats.FirstOrDefault(d => d.Name == deckName);
if (newStatsEntry == null)
{
newStatsEntry = new DeckStats(deckName);
DeckStatsList.Instance.DeckStats.Add(newStatsEntry);
}
foreach (var game in statsEntry.Games)
{
newStatsEntry.AddGameResult(game.CloneWithNewId());
}
Logger.WriteLine("cloned gamestats for \"Set as new\"");
}
DeckStatsList.Save();
}
}
}
//after cloning the stats, otherwise new stats will be generated
DeckPickerList.AddAndSelectDeck(newDeckClone);
EditingDeck = false;
foreach (var tag in _newDeck.Tags)
{
SortFilterDecksFlyout.AddSelectedTag(tag);
}
DeckPickerList.UpdateList();
DeckPickerList.SelectDeck(newDeckClone);
CloseNewDeck();
ClearNewDeckSection();
}
private async void SaveDeck(bool overwrite, SerializableVersion newVersion)
{
var deckName = TextBoxDeckName.Text;
if (string.IsNullOrEmpty(deckName))
{
var settings = new MetroDialogSettings {
AffirmativeButtonText = "Set", DefaultText = deckName
};
var name = await this.ShowInputAsync("No name set", "Please set a name for the deck", settings);
if (String.IsNullOrEmpty(name))
{
return;
}
deckName = name;
TextBoxDeckName.Text = name;
}
/*while(DeckList.DecksList.Any(d => d.Name == deckName) && (!EditingDeck || !overwrite))
* {
* var settings = new MetroDialogSettings {AffirmativeButtonText = "Set", DefaultText = deckName};
* var name =
* await
* this.ShowInputAsync("Name already exists", "You already have a deck with that name, please select a different one.", settings);
*
* if(String.IsNullOrEmpty(name))
* return;
*
* deckName = name;
* TextBoxDeckName.Text = name;
* }*/
if (_newDeck.Cards.Sum(c => c.Count) != 30)
{
var settings = new MetroDialogSettings {
AffirmativeButtonText = "Yes", NegativeButtonText = "No"
};
var result =
await
this.ShowMessageAsync("Not 30 cards",
string.Format("Deck contains {0} cards. Is this what you want to save anyway?",
_newDeck.Cards.Sum(c => c.Count)), MessageDialogStyle.AffirmativeAndNegative, settings);
if (result != MessageDialogResult.Affirmative)
{
return;
}
}
var previousVersion = _newDeck.Version;
if (overwrite && (_newDeck.Version != newVersion))
{
AddDeckHistory();
_newDeck.Version = newVersion;
_newDeck.SelectedVersion = newVersion;
_newDeck.HearthStatsDeckVersionId = "";
//UpdateDeckHistoryPanel(_newDeck, false);
}
if (EditingDeck && overwrite)
{
DeckList.Instance.Decks.Remove(_newDeck);
//DeckPickerList.RemoveDeck(_newDeck);
}
var oldDeckName = _newDeck.Name;
_newDeck.Name = deckName;
var newDeckClone = (Deck)_newDeck.Clone();
newDeckClone.Archived = false;
DeckList.Instance.Decks.Add(newDeckClone);
newDeckClone.LastEdited = DateTime.Now;
DeckList.Save();
Logger.WriteLine("Saved Decks", "SaveDeck");
if (EditingDeck)
{
TagControlEdit.SetSelectedTags(new List <string>());
if (deckName != oldDeckName)
{
var statsEntry = DeckStatsList.Instance.DeckStats.FirstOrDefault(ds => ds.BelongsToDeck(_newDeck));
if (statsEntry != null)
{
if (overwrite)
{
statsEntry.Name = deckName;
Logger.WriteLine("Deck has new name, updated deckstats", "SaveDeck");
}
else
{
var newStatsEntry = DeckStatsList.Instance.DeckStats.FirstOrDefault(ds => ds.BelongsToDeck(_newDeck));
if (newStatsEntry == null)
{
newStatsEntry = new DeckStats(_newDeck);
DeckStatsList.Instance.DeckStats.Add(newStatsEntry);
}
foreach (var game in statsEntry.Games)
{
newStatsEntry.AddGameResult(game.CloneWithNewId());
}
Logger.WriteLine("cloned gamestats for \"Set as new\"", "SaveDeck");
}
DeckStatsList.Save();
}
}
}
if (Config.Instance.HearthStatsAutoUploadNewDecks && HearthStatsAPI.IsLoggedIn)
{
Logger.WriteLine("auto uploading new/edited deck", "SaveDeck");
if (EditingDeck)
{
if (previousVersion != newVersion)
{
HearthStatsManager.UploadVersionAsync(newDeckClone, _originalDeck.HearthStatsIdForUploading, background: true);
}
else
{
HearthStatsManager.UpdateDeckAsync(newDeckClone, background: true);
}
}
else
{
HearthStatsManager.UploadDeckAsync(newDeckClone, background: true);
}
}
//after cloning the stats, otherwise new stats will be generated
//DeckPickerList.AddAndSelectDeck(newDeckClone);
EditingDeck = false;
foreach (var tag in _newDeck.Tags)
{
SortFilterDecksFlyout.AddSelectedTag(tag);
}
DeckPickerList.SelectDeckAndAppropriateView(newDeckClone);
CloseNewDeck();
ClearNewDeckSection();
}
private void BtnFile_Click(object sender, RoutedEventArgs e)
{
var dialog = new OpenFileDialog
{
Title = "Select Deck File",
DefaultExt = "*.xml;*.txt",
Filter = "Deck Files|*.txt;*.xml"
};
var dialogResult = dialog.ShowDialog();
if (dialogResult == true)
{
try
{
Deck deck = null;
if (dialog.FileName.EndsWith(".txt"))
{
using (var sr = new StreamReader(dialog.FileName))
{
deck = new Deck();
var lines = sr.ReadToEnd().Split('\n');
foreach (var line in lines)
{
var card = Game.GetCardFromName(line.Trim());
if (card.Name == "")
{
continue;
}
if (string.IsNullOrEmpty(deck.Class) && card.PlayerClass != "Neutral")
{
deck.Class = card.PlayerClass;
}
if (deck.Cards.Contains(card))
{
var deckCard = deck.Cards.First(c => c.Equals(card));
deck.Cards.Remove(deckCard);
deckCard.Count++;
deck.Cards.Add(deckCard);
}
else
{
deck.Cards.Add(card);
}
}
}
}
else if (dialog.FileName.EndsWith(".xml"))
{
deck = XmlManager <Deck> .Load(dialog.FileName);
//not all required information is saved in xml
foreach (var card in deck.Cards)
{
card.Load();
}
TagControlEdit.SetSelectedTags(deck.Tags);
}
SetNewDeck(deck);
}
catch (Exception ex)
{
Logger.WriteLine("Error getting deck from file: \n" + ex.Message + "\n" + ex.StackTrace);
}
}
}
public async void SaveDeck(bool overwrite, SerializableVersion newVersion, bool workInProgressDeck = false)
{
var deckName = TextBoxDeckName.Text;
if (string.IsNullOrEmpty(deckName))
{
var settings = new MessageDialogs.Settings {
AffirmativeButtonText = "Set", DefaultText = deckName
};
var name = await this.ShowInputAsync("No name set", "Please set a name for the deck", settings);
if (string.IsNullOrEmpty(name))
{
return;
}
deckName = name;
TextBoxDeckName.Text = name;
}
if (_newDeck.Cards.Sum(c => c.Count) != 30 && workInProgressDeck == false)
{
var settings = new MessageDialogs.Settings {
AffirmativeButtonText = "Yes", NegativeButtonText = "No"
};
var result =
await
this.ShowMessageAsync("Not 30 cards",
$"Deck contains {_newDeck.Cards.Sum(c => c.Count)} cards. Is this what you want to save anyway?", MessageDialogStyle.AffirmativeAndNegative, settings);
if (result != MessageDialogResult.Affirmative)
{
return;
}
}
var previousVersion = _newDeck.Version;
if (overwrite && (_newDeck.Version != newVersion))
{
AddDeckHistory();
_newDeck.Version = newVersion;
_newDeck.SelectedVersion = newVersion;
_newDeck.HearthStatsDeckVersionId = "";
}
if (EditingDeck && overwrite)
{
DeckList.Instance.Decks.Remove(_newDeck);
}
var oldDeckName = _newDeck.Name;
_newDeck.Name = deckName;
var newDeckClone = (Deck)_newDeck.Clone();
newDeckClone.Archived = false;
DeckList.Instance.Decks.Add(newDeckClone);
newDeckClone.LastEdited = DateTime.Now;
DeckList.Save();
Log.Info("Saved Decks");
if (EditingDeck)
{
TagControlEdit.SetSelectedTags(new List <string>());
if (deckName != oldDeckName)
{
var statsEntry = DeckStatsList.Instance.DeckStats.FirstOrDefault(ds => ds.BelongsToDeck(_newDeck));
if (statsEntry != null)
{
if (overwrite)
{
statsEntry.Name = deckName;
Log.Info("Deck has new name, updated deckstats");
foreach (var game in statsEntry.Games)
{
game.DeckName = deckName;
}
}
else
{
var newStatsEntry = DeckStatsList.Instance.DeckStats.FirstOrDefault(ds => ds.BelongsToDeck(_newDeck));
if (newStatsEntry == null)
{
newStatsEntry = new DeckStats(_newDeck);
DeckStatsList.Instance.DeckStats.Add(newStatsEntry);
}
foreach (var game in statsEntry.Games)
{
newStatsEntry.AddGameResult(game.CloneWithNewId());
}
Log.Info("cloned gamestats for \"Set as new\"");
}
DeckStatsList.Save();
}
}
}
if (Config.Instance.HearthStatsAutoUploadNewDecks && HearthStatsAPI.IsLoggedIn)
{
Log.Info("auto uploading new/edited deck");
if (EditingDeck)
{
if (previousVersion != newVersion)
{
HearthStatsManager.UploadVersionAsync(newDeckClone, _originalDeck.HearthStatsIdForUploading, background: true).Forget();
}
else
{
HearthStatsManager.UpdateDeckAsync(newDeckClone, background: true).Forget();
}
}
else
{
HearthStatsManager.UploadDeckAsync(newDeckClone, background: true).Forget();
}
}
if (EditingDeck)
{
DeckManagerEvents.OnDeckUpdated.Execute(newDeckClone);
}
else
{
DeckManagerEvents.OnDeckCreated.Execute(newDeckClone);
}
EditingDeck = false;
foreach (var tag in _newDeck.Tags)
{
SortFilterDecksFlyout.AddSelectedTag(tag);
}
DeckPickerList.SelectDeckAndAppropriateView(newDeckClone);
DeckPickerList.UpdateDecks(forceUpdate: new[] { newDeckClone });
SelectDeck(newDeckClone, true);
CloseNewDeck();
ClearNewDeckSection();
}
internal void BtnTags_Click(object sender, RoutedEventArgs e)
{
FlyoutMyDecksSetTags.IsOpen = true;
TagControlEdit.SetSelectedTags(DeckPickerList.SelectedDecks);
}
