public CustomDialog(MetroDialogSettings settings)
: this(null, settings)
{
}
private void HandleVisibility(MetroDialogSettings settings)
{
this.Loaded += this.Dialog_Loaded;
this.Unloaded += this.Dialog_Loaded;
}
protected override Task <MessageResult> ShowMessageBoxAsync(string message, string caption = "", MessageButton button = MessageButton.OK, MessageImage icon = MessageImage.None)
{
var style = MessageDialogStyle.Affirmative;
var affirmativeResult = MessageResult.OK;
var negativeResult = MessageResult.No;
var auxiliaryResult = MessageResult.Cancel;
MetroDialogSettings settings = new MetroDialogSettings();
switch (button)
{
case MessageButton.OK:
style = MessageDialogStyle.Affirmative;
affirmativeResult = MessageResult.OK;
settings.AffirmativeButtonText = _languageService.GetString("OK");
break;
case MessageButton.OKCancel:
style = MessageDialogStyle.AffirmativeAndNegative;
affirmativeResult = MessageResult.OK;
negativeResult = MessageResult.Cancel;
settings.AffirmativeButtonText = _languageService.GetString("OK");
settings.NegativeButtonText = _languageService.GetString("Cancel");
break;
case MessageButton.YesNo:
style = MessageDialogStyle.AffirmativeAndNegative;
affirmativeResult = MessageResult.Yes;
negativeResult = MessageResult.No;
settings.AffirmativeButtonText = _languageService.GetString("Yes");
settings.NegativeButtonText = _languageService.GetString("No");
break;
case MessageButton.YesNoCancel:
style = MessageDialogStyle.AffirmativeAndNegativeAndSingleAuxiliary;
affirmativeResult = MessageResult.Yes;
negativeResult = MessageResult.No;
auxiliaryResult = MessageResult.Cancel;
settings.AffirmativeButtonText = _languageService.GetString("Yes");
settings.NegativeButtonText = _languageService.GetString("No");
settings.FirstAuxiliaryButtonText = _languageService.GetString("Cancel");
break;
default:
throw new ArgumentOutOfRangeException("button");
}
var tcs = new TaskCompletionSource <MessageResult>();
#pragma warning disable AvoidAsyncVoid
_dispatcherService.BeginInvoke(async() =>
#pragma warning restore AvoidAsyncVoid
{
var window = Application.Current.MainWindow as MetroWindow;
if (window == null)
{
tcs.TrySetResult(MessageResult.Cancel);
return;
}
var result = await window.ShowMessageAsync(caption, message, style, settings);
switch (result)
{
case MessageDialogResult.Negative:
tcs.TrySetResult(negativeResult);
break;
case MessageDialogResult.Affirmative:
tcs.TrySetResult(affirmativeResult);
break;
case MessageDialogResult.FirstAuxiliary:
tcs.TrySetResult(auxiliaryResult);
break;
default:
throw new ArgumentOutOfRangeException();
}
});
return(tcs.Task);
}
public async Task <MessageDialogResult> ShowMessage(string windowTitle, string message,
MessageDialogStyle dialogStyle, MetroDialogSettings metroDialogSettings)
{
foreach (var window in Application.Current.Windows.OfType <MetroWindow>())
{
if (window.Name == "FormotsMainWindow")
{
window.MetroDialogOptions.ColorScheme = MetroDialogColorScheme.Accented;
return(await window.ShowMessageAsync(windowTitle, message, dialogStyle, metroDialogSettings));
}
}
return(MessageDialogResult.Negative);
}
public static async Task <MessageDialogResult> ShowMessageAsync(this object viewModel, string title, string message, MessageDialogStyle style = MessageDialogStyle.Affirmative, MetroDialogSettings settings = null)
{
return(await DialogCoordinator.Instance.ShowMessageAsync(viewModel, title, message, style, settings));
}
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;
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 Task <string> InputDeckURL()
{
var settings = new MetroDialogSettings();
var clipboard = Clipboard.ContainsText() ? Clipboard.GetText() : "";
var validUrls = new[]
{
"hearthstats",
"hss.io",
"hearthpwn",
"hearthhead",
"hearthstoneplayers",
"tempostorm",
"hearthstonetopdeck",
"hearthnews.fr",
"arenavalue",
"hearthstone-decks",
"heartharena",
"hearthstoneheroes",
"elitedecks",
"icy-veins",
"hearthbuilder"
};
if (validUrls.Any(clipboard.Contains))
{
settings.DefaultText = clipboard;
}
if (Config.Instance.DisplayNetDeckAd)
{
var result =
await
this.ShowMessageAsync("NetDeck",
"For easier (one-click!) web importing check out the NetDeck Chrome Extension!\n\n(This message will not be displayed again, no worries.)",
MessageDialogStyle.AffirmativeAndNegative,
new MetroDialogSettings { AffirmativeButtonText = "Show me!", NegativeButtonText = "No thanks" });
if (result == MessageDialogResult.Affirmative)
{
Process.Start("https://chrome.google.com/webstore/detail/netdeck/lpdbiakcpmcppnpchohihcbdnojlgeel");
var enableOptionResult =
await
this.ShowMessageAsync("Enable one-click importing?",
"Would you like to enable one-click importing via NetDeck?\n(options > other > importing)",
MessageDialogStyle.AffirmativeAndNegative,
new MetroDialogSettings { AffirmativeButtonText = "Yes", NegativeButtonText = "No" });
if (enableOptionResult == MessageDialogResult.Affirmative)
{
Options.OptionsTrackerImporting.CheckboxImportNetDeck.IsChecked = true;
Config.Instance.NetDeckClipboardCheck = true;
Config.Save();
}
}
Config.Instance.DisplayNetDeckAd = false;
Config.Save();
}
//import dialog
var url =
await this.ShowInputAsync("Import deck", "Supported websites:\n" + validUrls.Aggregate((x, next) => x + ", " + next), settings);
return(url);
}
private async void clickSwitch(Object obj)
{
switch (obj.ToString())
{
case "menu_editar":
if (_selectedItem != null)
{
EditarVisible = true;
NuevoVisible = false;
GuardarMenuEnabled = true;
AgregarMenuEnabled = false;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = true;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = false;
AgregarVisible = true;
bandera_editar = true;
FocusText = true;
Nombre = _selectedItem.Paterno;
Descripcion = _selectedItem.Materno;
TipoBusquedaSelected = _selectedItem.Estatura;
CeresoSelected = _selectedItem.Edad;
if (_selectedItem.IsSelected)
{
FijaSelected = true;
}
else
{
MovilSelected = true;
}
if (_selectedItem.IsSelected)
{
VerificacionSelected = "S";
}
else
{
VerificacionSelected = "N";
}
AlmacenSelected = _selectedItem.Nombre;
}
else
{
bandera_editar = false;
var met = Application.Current.Windows[0] as MetroWindow;
await met.ShowMessageAsync("Validación", "Debe seleccionar una opcion.");
}
break;
case "menu_agregar":
EditarVisible = false;
NuevoVisible = true;
GuardarMenuEnabled = true;
AgregarMenuEnabled = false;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = true;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = false;
AgregarVisible = true;
bandera_editar = false;
FocusText = true;
LimpiarCampos();
break;
case "menu_guardar":
string tipoUA = "";
bool verif;
if (bandera_editar == false)
{
if (FijaSelected)
{
tipoUA = "FIJA";
}
else if (MovilSelected)
{
tipoUA = "MOVIL";
}
if (VerificacionSelected == "S")
{
verif = true;
}
else
{
verif = false;
}
ListItems.Add(new Persona()
{
Edad = CeresoSelected,
Estatura = TipoBusquedaSelected,
IsSelected = verif,
Materno = Descripcion,
Paterno = Nombre,
Nombre = AlmacenSelected,
Sexo = tipoUA
});
}
else
{
if (FijaSelected)
{
tipoUA = "FIJA";
}
else if (MovilSelected)
{
tipoUA = "MOVIL";
}
if (VerificacionSelected == "S")
{
verif = true;
}
else
{
verif = false;
}
SelectedItem.Edad = CeresoSelected;
SelectedItem.Estatura = TipoBusquedaSelected;
SelectedItem.IsSelected = verif;
SelectedItem.Materno = Descripcion;
SelectedItem.Paterno = Nombre;
SelectedItem.Nombre = AlmacenSelected;
SelectedItem.Sexo = tipoUA;
}
EditarVisible = false;
NuevoVisible = false;
GuardarMenuEnabled = false;
AgregarMenuEnabled = true;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = false;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = true;
AgregarVisible = false;
SelectedItem = null;
SeleccionIndice = -1;
VerificacionIndice = -1;
CeresoIndice = -1;
TipoBusquedaIndice = -1;
AlmacenIndice = -1;
LimpiarCampos();
break;
case "menu_cancelar":
NuevoVisible = false;
GuardarMenuEnabled = false;
AgregarMenuEnabled = true;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = false;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = true;
AgregarVisible = false;
SelectedItem = null;
SeleccionIndice = -1;
VerificacionIndice = -1;
CeresoIndice = -1;
TipoBusquedaIndice = -1;
AlmacenIndice = -1;
LimpiarCampos();
break;
case "menu_eliminar":
var metro = Application.Current.Windows[0] as MetroWindow;
if (_selectedItem != null)
{
var mySettings = new MetroDialogSettings()
{
AffirmativeButtonText = "Aceptar",
NegativeButtonText = "Cancelar",
AnimateShow = true,
AnimateHide = false
};
var result = await metro.ShowMessageAsync("Borrar", "¿Está seguro que desea borrar esto? [ " + 1 + " ]", MessageDialogStyle.AffirmativeAndNegative, mySettings);
if (result == MessageDialogResult.Affirmative)
{
var i = ListItems.IndexOf(_selectedItem);
if (i >= 0)
{
ListItems.RemoveAt(i);
var dialog = (BaseMetroDialog)metro.Resources["ConfirmacionDialog"];
await metro.ShowMetroDialogAsync(dialog);
await TaskEx.Delay(1500);
await metro.HideMetroDialogAsync(dialog);
//MENSAJE EXTERNO
//dialog = dialog.ShowDialogExternally();
//await TaskEx.Delay(1500);
//await dialog.RequestCloseAsync();
}
}
}
else
{
await metro.ShowMessageAsync("Validación", "Debe seleccionar una opcion");
}
SelectedItem = null;
SeleccionIndice = -1;
VerificacionIndice = -1;
CeresoIndice = -1;
TipoBusquedaIndice = -1;
AlmacenIndice = -1;
LimpiarCampos();
break;
case "menu_exportar":
SelectedItem = null;
SeleccionIndice = -1;
VerificacionIndice = -1;
CeresoIndice = -1;
TipoBusquedaIndice = -1;
AlmacenIndice = -1;
LimpiarCampos();
break;
case "menu_ayuda":
SelectedItem = null;
SeleccionIndice = -1;
VerificacionIndice = -1;
CeresoIndice = -1;
TipoBusquedaIndice = -1;
AlmacenIndice = -1;
LimpiarCampos();
break;
case "menu_salir":
SelectedItem = null;
SeleccionIndice = -1;
VerificacionIndice = -1;
CeresoIndice = -1;
TipoBusquedaIndice = -1;
AlmacenIndice = -1;
LimpiarCampos();
break;
}
if (_selectedItem == null)
{
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
}
}
public SettingsViewModel(CommonSettingsModel commonSettingsModel)
{
commonSettingsModel.PropertyChanged += Instance_PropertyChanged;
DefaultButtonCommand = new DelegateCommand <object>(async(c) =>
{
var mySetting = new MetroDialogSettings()
{
AffirmativeButtonText = International.GetText("Global_Yes"),
NegativeButtonText = International.GetText("Global_No"),
AnimateShow = true,
AnimateHide = false
};
var result = await _dialogCoordinator.ShowMessageAsync(this, International.GetText("Form_Settings_buttonDefaultsTitle"), International.GetText("Form_Settings_buttonDefaultsMsg"), MessageDialogStyle.AffirmativeAndNegative, mySetting);
if (result == MessageDialogResult.Affirmative)
{
IsChange = true;
IsChangeSaved = true;
ConfigManager.GeneralConfig.SetDefaults();
International.Initialize(ConfigManager.GeneralConfig.Language);
}
CloseWindow((Window)c);
});
SaveAndCloseButtonCommand = new DelegateCommand <object>(async(c) =>
{
var mySetting = new MetroDialogSettings()
{
AffirmativeButtonText = International.GetText("Global_OK"),
AnimateShow = true,
AnimateHide = false,
};
await _dialogCoordinator.ShowMessageAsync(this, International.GetText("Form_Settings_buttonSaveTitle"),
International.GetText("Form_Settings_buttonSaveMsg"),
MessageDialogStyle.Affirmative, mySetting);
IsChange = true;
IsChangeSaved = true;
CloseWindow((Window)c);
});
CloseButtonCommand = new DelegateCommand <object>(async(c) =>
{
IsChangeSaved = false;
if (IsChange && !IsChangeSaved)
{
var mySetting = new MetroDialogSettings()
{
AffirmativeButtonText = International.GetText("Global_Yes"),
NegativeButtonText = International.GetText("Global_No"),
AnimateShow = true,
AnimateHide = false,
};
var result = await _dialogCoordinator.ShowMessageAsync(this, International.GetText("Form_Settings_buttonCloseNoSaveTitle"), International.GetText("Form_Settings_buttonCloseNoSaveMsg"),
MessageDialogStyle.AffirmativeAndNegative, mySetting);
if (result == MessageDialogResult.Negative)
{
return;
}
else
{
CloseWindow((Window)c);
}
}
CloseWindow((Window)c);
});
WindowClosing = new DelegateCommand <object>(
(args) => {
// check restart parameters change
IsRestartNeeded = ConfigManager.IsRestartNeeded();
if (IsChangeSaved)
{
ConfigManager.GeneralConfigFileCommit();
ConfigManager.CommitBenchmarks();
International.Initialize(ConfigManager.GeneralConfig.Language);
}
else
{
ConfigManager.RestoreBackup();
}
});
}
private async void MetroWindowMain_Closing(object sender, CancelEventArgs e)
{
// Force restart (if user has reset the settings or import them)
if (SettingsManager.ForceRestart || ImportExportManager.ForceRestart)
{
RestartApplication(false);
_closeApplication = true;
}
// Hide the application to tray
if (!_closeApplication && (SettingsManager.Current.Window_MinimizeInsteadOfTerminating && WindowState != WindowState.Minimized))
{
e.Cancel = true;
WindowState = WindowState.Minimized;
return;
}
// Confirm close
if (!_closeApplication && SettingsManager.Current.Window_ConfirmClose)
{
e.Cancel = true;
// If the window is minimized, bring it to front
if (WindowState == WindowState.Minimized)
{
BringWindowToFront();
}
MetroDialogSettings settings = AppearanceManager.MetroDialog;
settings.AffirmativeButtonText = LocalizationManager.GetStringByKey("String_Button_Close");
settings.NegativeButtonText = LocalizationManager.GetStringByKey("String_Button_Cancel");
settings.DefaultButtonFocus = MessageDialogResult.Affirmative;
// Fix airspace issues
ConfigurationManager.Current.FixAirspace = true;
MessageDialogResult result = await this.ShowMessageAsync(LocalizationManager.GetStringByKey("String_Header_Confirm"), LocalizationManager.GetStringByKey("String_ConfirmCloseQuesiton"), MessageDialogStyle.AffirmativeAndNegative, settings);
ConfigurationManager.Current.FixAirspace = false;
if (result == MessageDialogResult.Affirmative)
{
_closeApplication = true;
Close();
}
return;
}
// Unregister HotKeys
if (RegisteredHotKeys.Count > 0)
{
UnregisterHotKeys();
}
// Dispose the notify icon to prevent errors
if (notifyIcon != null)
{
notifyIcon.Dispose();
}
}
private async void CloseSettings()
{
ShowSettingsView = false;
// Enable/disable tray icon
if (!_isInTray)
{
if (SettingsManager.Current.TrayIcon_AlwaysShowIcon && notifyIcon == null)
{
InitNotifyIcon();
}
if (notifyIcon != null)
{
notifyIcon.Visible = SettingsManager.Current.TrayIcon_AlwaysShowIcon;
}
MetroWindowMain.HideOverlay();
}
// Ask the user to restart (if he has changed the language)
if ((_cultureCode != SettingsManager.Current.Localization_CultureCode) || (AllowsTransparency != SettingsManager.Current.Appearance_EnableTransparency))
{
ShowWindowAction();
MetroDialogSettings settings = AppearanceManager.MetroDialog;
settings.AffirmativeButtonText = LocalizationManager.GetStringByKey("String_Button_RestartNow");
settings.NegativeButtonText = LocalizationManager.GetStringByKey("String_Button_OK");
settings.DefaultButtonFocus = MessageDialogResult.Affirmative;
ConfigurationManager.Current.FixAirspace = true;
if (await this.ShowMessageAsync(LocalizationManager.GetStringByKey("String_RestartRequired"), LocalizationManager.GetStringByKey("String_RestartRequiredAfterSettingsChanged"), MessageDialogStyle.AffirmativeAndNegative, settings) == MessageDialogResult.Affirmative)
{
RestartApplication();
return;
}
ConfigurationManager.Current.FixAirspace = false;
}
// Change the transparency
if ((AllowsTransparency != SettingsManager.Current.Appearance_EnableTransparency) || (Opacity != SettingsManager.Current.Appearance_Opacity))
{
if (!AllowsTransparency || !SettingsManager.Current.Appearance_EnableTransparency)
{
Opacity = 1;
}
else
{
Opacity = SettingsManager.Current.Appearance_Opacity;
}
}
// Change HotKeys
if (SettingsManager.HotKeysChanged)
{
UnregisterHotKeys();
RegisterHotKeys();
SettingsManager.HotKeysChanged = false;
}
// Save the settings
if (SettingsManager.Current.SettingsChanged)
{
SettingsManager.Save();
}
}
private async void clickSwitch(Object obj)
{
switch (obj.ToString())
{
case "buscar":
this.GetTiposUnidadMedida();
break;
case "menu_editar":
if (SelectedItem != null)
{
HeaderAgregar = "Editar Motivo de Solicitud EStudio";
#region visiblePantalla
EditarVisible = true;
NuevoVisible = false;
GuardarMenuEnabled = true;
AgregarMenuEnabled = false;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = true;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = false;
AgregarVisible = true;
#endregion
bandera_editar = true;
FocusText = true;
/*****************************************/
Clave = SelectedItem.ID_MOTIVO;
Descripcion = SelectedItem.DESCR;
/*****************************************/
PopularEstatusCombo();
SelectedEstatus = Lista_Estatus.LISTA_ESTATUS.Where(w => w.CLAVE == SelectedItem.ESTATUS).SingleOrDefault();
setValidationRules();
//TODO:Falta Agregar campo estatus
//SelectedEstatus=ListEstatus.Where(w=>w.CLAVE==selectedItem.Id_Estatus)
}
else
{
bandera_editar = false;
var met = Application.Current.Windows[0] as MetroWindow;
await met.ShowMessageAsync("Validación", "Debe seleccionar una opción.");
}
break;
case "menu_agregar":
HeaderAgregar = "Agregar Nuevo Motivo de Solicitud Estudio";
#region visiblePantalla
EditarVisible = false;
NuevoVisible = true;
GuardarMenuEnabled = true;
AgregarMenuEnabled = false;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = true;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = false;
AgregarVisible = true;
#endregion
bandera_editar = false;
FocusText = true;
/********************************/
SeleccionIndice = -1;
Clave = 0;
SelectedEstatus = null;
SelectedEstatus = Lista_Estatus.LISTA_ESTATUS.Where(w => w.CLAVE == "S").FirstOrDefault();
SelectedItem = null;
Descripcion = string.Empty;
Abreviatura = string.Empty;
PopularEstatusCombo();
setValidationRules();
/********************************/
break;
case "menu_guardar":
if (!string.IsNullOrEmpty(Descripcion))
{
#region visiblePantalla
EditarVisible = false;
NuevoVisible = false;
GuardarMenuEnabled = false;
AgregarMenuEnabled = true;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = false;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = true;
AgregarVisible = false;
#endregion
/**********************************/
this.GuardarUnidadMedida();
/**********************************/
}
else
{
FocusText = true;
}
break;
case "menu_cancelar":
#region visiblePantalla
NuevoVisible = false;
GuardarMenuEnabled = false;
AgregarMenuEnabled = true;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = false;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = true;
AgregarVisible = false;
#endregion
/****************************************/
SeleccionIndice = -1;
Clave = 0;
Descripcion = string.Empty;
Busqueda = string.Empty;
this.GetTiposUnidadMedida();
/****************************************/
break;
case "menu_eliminar":
var metro = Application.Current.Windows[0] as MetroWindow;
if (SelectedItem != null)
{
var mySettings = new MetroDialogSettings()
{
AffirmativeButtonText = "Aceptar",
NegativeButtonText = "Cancelar",
AnimateShow = true,
AnimateHide = false
};
var result = await metro.ShowMessageAsync("Borrar", "¿Está seguro que desea borrar esto? [ " + SelectedItem.DESCR + " ]", MessageDialogStyle.AffirmativeAndNegative, mySettings);
if (result == MessageDialogResult.Affirmative)
{
BaseMetroDialog dialog;
if (EliminarTipoEstudio())
{
dialog = (BaseMetroDialog)metro.Resources["ConfirmacionDialog"];
}
else
{
dialog = (BaseMetroDialog)metro.Resources["ErrorDialog"];
}
await metro.ShowMetroDialogAsync(dialog);
await TaskEx.Delay(1500);
await metro.HideMetroDialogAsync(dialog);
}
}
else
{
await metro.ShowMessageAsync("Validación", "Debe seleccionar una opción");
}
SeleccionIndice = -1;
break;
case "menu_exportar":
SeleccionIndice = -1;
Cambio = string.Empty;
break;
case "menu_ayuda":
SeleccionIndice = -1;
Cambio = string.Empty;
break;
case "menu_salir":
SeleccionIndice = -1;
Cambio = string.Empty;
PrincipalViewModel.SalirMenu();
break;
}
}
public async void ClickSwitch(object obj)
{
switch (obj.ToString())
{
case "GenerarReporte":
if (!pConsultar)
{
ReportViewerVisible = Visibility.Collapsed;
new Dialogos().ConfirmacionDialogo("Validación", "Su usuario no tiene privilegios para realizar esta acción");
break;
}
if (!ListaIngresosSeleccionados.Any())
{
var mensaje = System.Windows.Application.Current.Windows[0] as MetroWindow;
var mySettings = new MetroDialogSettings()
{
AffirmativeButtonText = "Cerrar",
AnimateShow = true,
AnimateHide = false
};
ReportViewerVisible = Visibility.Collapsed;
await mensaje.ShowMessageAsync("Validación", "Debe seleccionar al menos un interno para generar el reporte.", MessageDialogStyle.Affirmative, mySettings);
ReportViewerVisible = Visibility.Visible;
}
else
{
Reporte.Reset();
GenerarReporte();
}
break;
case "ObtenerIngresos":
try
{
if (!pConsultar)
{
ReportViewerVisible = Visibility.Collapsed;
new Dialogos().ConfirmacionDialogo("Validación", "Su usuario no tiene privilegios para realizar esta acción");
break;
}
await StaticSourcesViewModel.CargarDatosMetodoAsync(() =>
{
Application.Current.Dispatcher.Invoke((Action)(delegate
{
ReportViewerVisible = Visibility.Collapsed;
}));
Pagina = 1;
ListaIngresos = new List <cFormatoIdentificacion>();
EmptyVisible = true;
ObtenerIngresos();
Application.Current.Dispatcher.Invoke((Action)(delegate
{
ReportViewerVisible = Visibility.Visible;
}));
});
}
catch (Exception ex)
{
throw new ApplicationException(ex.Message);
}
break;
case "Permitir":
if (!SelectedIngreso.Seleccionado)
{
SeleccionarTodosIngresos = false;
}
else
{
SeleccionarTodosIngresos = !ListaIngresos.Where(w => !w.Seleccionado).Any();
}
break;
case "SeleccionarTodosIngresos":
if (ListaIngresos.Any())
{
var lista_ingresos = new List <cFormatoIdentificacion>(ListaIngresos);
foreach (var Ingreso in lista_ingresos)
{
Ingreso.Seleccionado = SeleccionarTodosIngresos;
}
ListaIngresos = lista_ingresos;
}
else
{
SeleccionarTodosIngresos = false;
}
break;
case "PermitirSeleccionado":
if (!SelectedIngresoSeleccionado.Seleccionado)
{
SeleccionarTodosIngresosSeleccionados = false;
}
else
{
SeleccionarTodosIngresosSeleccionados = !ListaIngresosSeleccionados.Where(w => !w.Seleccionado).Any();
}
break;
case "SeleccionarTodosIngresosSeleccionados":
if (ListaIngresosSeleccionados.Any())
{
var lista_ingresos_Seleccionados = new List <cFormatoIdentificacion>(ListaIngresosSeleccionados);
foreach (var Ingreso in lista_ingresos_Seleccionados)
{
Ingreso.Seleccionado = SeleccionarTodosIngresosSeleccionados;
}
ListaIngresosSeleccionados = lista_ingresos_Seleccionados;
}
else
{
SeleccionarTodosIngresosSeleccionados = false;
}
break;
case "AgregarInternos":
if (ListaIngresos.Any())
{
if (ListaIngresos.Where(w => w.Seleccionado).Any())
{
var lista_ingresos = new List <cFormatoIdentificacion>(ListaIngresos);
var lista_ingresos_Seleccionados = new List <cFormatoIdentificacion>(
ListaIngresos.Where(w => w.Seleccionado).
OrderByDescending(oD => oD.Id_Anio).
ThenByDescending(tD => tD.Id_Imputado).
ToList());
foreach (var ingreso_Seleccionado in lista_ingresos_Seleccionados)
{
ingreso_Seleccionado.Seleccionado = false;
lista_ingresos.Remove(ingreso_Seleccionado);
}
ListaIngresos = lista_ingresos.Any() ? lista_ingresos.OrderByDescending(oD => oD.Id_Anio).ThenByDescending(tD => tD.Id_Imputado).ToList() : new List <cFormatoIdentificacion>();
EmptyVisible = !ListaIngresos.Any();
EmptySeleccionadosVisible = false;
ListaIngresosSeleccionados.AddRange(lista_ingresos_Seleccionados);
ListaIngresosSeleccionados = ListaIngresosSeleccionados.OrderByDescending(oD => oD.Id_Anio).ThenByDescending(tD => tD.Id_Imputado).ToList();
SeleccionarTodosIngresos = false;
}
else
{
var mensaje = System.Windows.Application.Current.Windows[0] as MetroWindow;
var mySettings = new MetroDialogSettings()
{
AffirmativeButtonText = "Cerrar",
AnimateShow = true,
AnimateHide = false
};
ReportViewerVisible = Visibility.Collapsed;
await mensaje.ShowMessageAsync("Validación", "Debe seleccionar al menos un interno.", MessageDialogStyle.Affirmative, mySettings);
ReportViewerVisible = Visibility.Visible;
}
}
else
{
var mensaje = System.Windows.Application.Current.Windows[0] as MetroWindow;
var mySettings = new MetroDialogSettings()
{
AffirmativeButtonText = "Cerrar",
AnimateShow = true,
AnimateHide = false
};
ReportViewerVisible = Visibility.Collapsed;
await mensaje.ShowMessageAsync("Validación", "Lista de internos vacía. Realice una búsqueda e intente de nuevo.", MessageDialogStyle.Affirmative, mySettings);
ReportViewerVisible = Visibility.Visible;
}
break;
case "RemoverInternos":
if (ListaIngresosSeleccionados.Any())
{
if (ListaIngresosSeleccionados.Where(w => w.Seleccionado).Any())
{
var lista_ingresos = new List <cFormatoIdentificacion>(ListaIngresosSeleccionados);
var lista_ingresos_Seleccionados = new List <cFormatoIdentificacion>(
ListaIngresosSeleccionados.Where(w => w.Seleccionado).
OrderByDescending(oD => oD.Id_Anio).
ThenByDescending(tD => tD.Id_Imputado).
ToList());
foreach (var ingreso_Seleccionado in lista_ingresos_Seleccionados)
{
ingreso_Seleccionado.Seleccionado = false;
lista_ingresos.Remove(ingreso_Seleccionado);
}
ListaIngresosSeleccionados = lista_ingresos.Any() ? lista_ingresos.OrderByDescending(oD => oD.Id_Anio).ThenByDescending(tD => tD.Id_Imputado).ToList() : new List <cFormatoIdentificacion>();
EmptySeleccionadosVisible = !ListaIngresosSeleccionados.Any();
EmptyVisible = false;
ListaIngresos.AddRange(lista_ingresos_Seleccionados);
ListaIngresos = ListaIngresos.OrderByDescending(oD => oD.Id_Anio).ThenByDescending(tD => tD.Id_Imputado).ToList();
SeleccionarTodosIngresosSeleccionados = false;
}
else
{
var mensaje = System.Windows.Application.Current.Windows[0] as MetroWindow;
var mySettings = new MetroDialogSettings()
{
AffirmativeButtonText = "Cerrar",
AnimateShow = true,
AnimateHide = false
};
ReportViewerVisible = Visibility.Collapsed;
await mensaje.ShowMessageAsync("Validación", "Debe seleccionar al menos un interno.", MessageDialogStyle.Affirmative, mySettings);
ReportViewerVisible = Visibility.Visible;
}
}
else
{
var mensaje = System.Windows.Application.Current.Windows[0] as MetroWindow;
var mySettings = new MetroDialogSettings()
{
AffirmativeButtonText = "Cerrar",
AnimateShow = true,
AnimateHide = false
};
ReportViewerVisible = Visibility.Collapsed;
await mensaje.ShowMessageAsync("Validación", "Lista de internos Seleccionados vacía.", MessageDialogStyle.Affirmative, mySettings);
ReportViewerVisible = Visibility.Visible;
}
break;
}
}
public async void SaveDeck(bool overwrite, SerializableVersion newVersion, bool workInProgressDeck = false)
{
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;
}
if (_newDeck.Cards.Sum(c => c.Count) != 30 && workInProgressDeck == false)
{
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 = "";
}
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();
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");
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());
}
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);
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();
}
private async void clickSwitch(Object obj)
{
var metro = Application.Current.Windows[0] as MetroWindow;
switch (obj.ToString())
{
case "menu_editar":
if (_selectedItem != null)
{
IngredientesVisible = true;
NuevaRecetaVisible = true;
BotonesVisible = false;
bandera_editar = true;
FocusText = true;
Cambio = _selectedItem.Username;
GuardarMenuEnabled = true;
AgregarMenuEnabled = false;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = true;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = true;
ListItems2.Clear();
if (_selectedItem.Password == "12345")
{
ListItems2.Add(new Usuario()
{
Username = "******", Password = "******"
});
ListItems2.Add(new Usuario()
{
Username = "******", Password = "******"
});
}
else
{
ListItems2.Add(new Usuario()
{
Username = "******", Password = "******"
});
ListItems2.Add(new Usuario()
{
Username = "******", Password = "******"
});
}
}
else
{
bandera_editar = false;
await metro.ShowMessageAsync("Validación", "Debe seleccionar una opcion.");
}
break;
case "menu_agregar":
IngredientesVisible = false;
NuevaRecetaVisible = true;
BotonesVisible = true;
bandera_editar = false;
FocusText = true;
Cambio = string.Empty;
GuardarMenuEnabled = true;
AgregarMenuEnabled = false;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = true;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = true;
break;
case "boton_aceptar_receta":
if (_selectedReceta != null)
{
IngredientesVisible = false;
NuevaRecetaVisible = false;
bandera_editar = false;
FocusText = false;
GuardarMenuEnabled = false;
AgregarMenuEnabled = true;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = false;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = true;
}
else
{
await metro.ShowMessageAsync("Validación", "Debe seleccionar una opcion.");
}
break;
case "boton_cancelar_receta":
IngredientesVisible = false;
NuevaRecetaVisible = false;
bandera_editar = false;
FocusText = false;
GuardarMenuEnabled = false;
AgregarMenuEnabled = true;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = false;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = true;
break;
case "menu_guardar":
if (bandera_editar == false)
{
_selectedItem = null;
_selectedItem = new Usuario()
{
Username = Cambio, Password = "******"
};
ListItems.Add(_selectedItem);
IngredientesVisible = true;
NuevaRecetaVisible = false;
AgregarMenuEnabled = false;
ListItems2.Clear();
if (_selectedItem.Password == "12345")
{
ListItems2.Add(new Usuario()
{
Username = "******", Password = "******"
});
ListItems2.Add(new Usuario()
{
Username = "******", Password = "******"
});
}
else
{
ListItems2.Add(new Usuario()
{
Username = "******", Password = "******"
});
ListItems2.Add(new Usuario()
{
Username = "******", Password = "******"
});
}
}
else
{
SelectedItem.Username = Cambio;
IngredientesVisible = false;
NuevaRecetaVisible = false;
}
bandera_editar = false;
FocusText = false;
SelectedItem = null;
SeleccionIndice = -1;
Cambio = string.Empty;
GuardarMenuEnabled = false;
AgregarMenuEnabled = true;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = false;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = true;
break;
case "menu_cancelar":
IngredientesVisible = false;
NuevaRecetaVisible = false;
bandera_editar = false;
FocusText = false;
SelectedItem = null;
SeleccionIndice = -1;
Cambio = string.Empty;
GuardarMenuEnabled = false;
AgregarMenuEnabled = true;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = false;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = true;
break;
case "menu_eliminar":
if (_selectedItem != null)
{
var mySettings = new MetroDialogSettings()
{
AffirmativeButtonText = "Aceptar",
NegativeButtonText = "Cancelar",
AnimateShow = true,
AnimateHide = false
};
// SALTO DE LINEA
// string.Format("\n")
var result = await metro.ShowMessageAsync("Borrar", "¿Está seguro que desea borrar esto? [ " + SelectedItem.Username + " ]", MessageDialogStyle.AffirmativeAndNegative, mySettings);
if (result == MessageDialogResult.Affirmative)
{
var i = ListItems.IndexOf(_selectedItem);
if (i >= 0)
{
ListItems.RemoveAt(i);
var dialog = (BaseMetroDialog)metro.Resources["ConfirmacionDialog"];
await metro.ShowMetroDialogAsync(dialog);
await TaskEx.Delay(1500);
await metro.HideMetroDialogAsync(dialog);
//MENSAJE EXTERNO
//dialog = dialog.ShowDialogExternally();
//await TaskEx.Delay(1500);
//await dialog.RequestCloseAsync();
}
}
}
else
{
await metro.ShowMessageAsync("Validación", "Debe seleccionar una opcion");
}
SelectedItem = null;
SeleccionIndice = -1;
Cambio = string.Empty;
GuardarMenuEnabled = false;
AgregarMenuEnabled = true;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = false;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = true;
break;
case "menu_exportar":
SelectedItem = null;
SeleccionIndice = -1;
Cambio = string.Empty;
break;
case "menu_ayuda":
SelectedItem = null;
SeleccionIndice = -1;
Cambio = string.Empty;
break;
case "menu_salir":
SelectedItem = null;
SeleccionIndice = -1;
Cambio = string.Empty;
break;
}
}
// ****************************************************************************************************
// ﾒｿｯﾄﾞ定義
// ****************************************************************************************************
/// <summary>
/// ﾒｯｾｰｼﾞﾀﾞｲｱﾛｸﾞを表示します。
/// </summary>
/// <param name="title">ﾀｲﾄﾙ</param>
/// <param name="message">ﾒｯｾｰｼﾞ</param>
/// <param name="style">ﾀﾞｲｱﾛｸﾞｽﾀｲﾙ</param>
/// <param name="settings">設定情報</param>
/// <returns><code>MessageDialogResult</code></returns>
public async Task <MessageDialogResult> ShowMessageAsync(string title, string message, MessageDialogStyle style = MessageDialogStyle.Affirmative, MetroDialogSettings settings = null)
{
return(await DialogCoordinator.ShowMessageAsync(this, title, message, style, settings));
}
private async Task <bool> Authenticate()
{
MetroDialogSettings approveLoginDialogSettings = new MetroDialogSettings
{
AffirmativeButtonText = "Yes",
NegativeButtonText = "No",
FirstAuxiliaryButtonText = "Yes, but don't save my password",
DefaultButtonFocus = MessageDialogResult.Affirmative,
AnimateHide = true,
AnimateShow = true,
};
MetroWindow mainWindow = ((MetroWindow)Window.GetWindow(this));
var approveLogin = await mainWindow.ShowMessageAsync("Do you want to log in with your MyAnimeList account?", "If you don't log in, Kian will not be able to read info about shows from MAL", MessageDialogStyle.AffirmativeAndNegativeAndSingleAuxiliary, approveLoginDialogSettings);
if (approveLogin == MessageDialogResult.Negative)
{
Authenticated = false;
return(false);
}
else if (approveLogin == MessageDialogResult.Affirmative)
{
saveLogin = true;
}
else if (approveLogin == MessageDialogResult.FirstAuxiliary)
{
saveLogin = false;
}
LoginDialogData login = await mainWindow.ShowLoginAsync("Enter your MAL login:"******"By logging in, your password will be encrypted using DPAPI and saved until next time.");
NetworkCredential loginCredentials = new NetworkCredential(login.Username, login.Password);
if (!string.IsNullOrEmpty(loginCredentials.UserName) &&
!string.IsNullOrEmpty(loginCredentials.Password) &&
API.Authentication.VerifyCredentials(loginCredentials))
{
this.login = loginCredentials;
Authenticated = true;
return(true);
}
else
{
MetroDialogSettings retryDialogSettings = new MetroDialogSettings()
{
AffirmativeButtonText = "Yes",
NegativeButtonText = "No",
AnimateHide = true,
AnimateShow = true,
DefaultButtonFocus = MessageDialogResult.Affirmative,
};
MessageDialogResult retry = await mainWindow.ShowMessageAsync("Your MyAnimeList login could not be verified.", "Do you want to try re-entering it?", MessageDialogStyle.AffirmativeAndNegative, retryDialogSettings);
if (retry == MessageDialogResult.Affirmative)
{
return(await Authenticate());
}
else
{
Authenticated = false;
return(false);
}
}
}
/// <summary>
/// 入力ﾀﾞｲｱﾛｸﾞを表示します。
/// </summary>
/// <param name="title">ﾀｲﾄﾙ</param>
/// <param name="message">ﾒｯｾｰｼﾞ</param>
/// <param name="settings">設定情報</param>
/// <returns>入力値</returns>
public async Task <string> ShowInputAsync(string title, string message, MetroDialogSettings settings = null)
{
return(await DialogCoordinator.ShowInputAsync(this, title, message, settings));
}
private async void BtnSaveDeck_Click(object sender, RoutedEventArgs e)
{
//NewDeck.Cards =
// new ObservableCollection<Card>(
// NewDeck.Cards.OrderBy(c => c.Cost).ThenByDescending(c => c.Type).ThenBy(c => c.Name).ToList());
//ListViewNewDeck.ItemsSource = NewDeck.Cards;
var deckName = TextBoxDeckName.Text;
if (EditingDeck)
{
var settings = new MetroDialogSettings {
AffirmativeButtonText = "Overwrite", NegativeButtonText = "Save as new"
};
var result =
await
this.ShowMessageAsync("Saving deck", "How do you wish to save the deck?", MessageDialogStyle.AffirmativeAndNegative,
settings);
if (result == MessageDialogResult.Affirmative)
{
SaveDeck(true);
}
else if (result == MessageDialogResult.Negative)
{
SaveDeck(false);
}
}
else if (DeckList.DecksList.Any(d => d.Name == deckName))
{
var settings = new MetroDialogSettings {
AffirmativeButtonText = "Overwrite", NegativeButtonText = "Set new name"
};
var keepStatsInfo = Config.Instance.KeepStatsWhenDeletingDeck
? "The stats will be moved to the default-deck (can be changed in options)"
: "The stats will be deleted (can be changed in options)";
var result =
await
this.ShowMessageAsync("A deck with that name already exists", "Overwriting the deck can not be undone!\n" + keepStatsInfo,
MessageDialogStyle.AffirmativeAndNegative, settings);
if (result == MessageDialogResult.Affirmative)
{
Deck oldDeck;
while ((oldDeck = DeckList.DecksList.FirstOrDefault(d => d.Name == deckName)) != null)
{
DeleteDeck(oldDeck);
}
SaveDeck(true);
}
else if (result == MessageDialogResult.Negative)
{
SaveDeck(false);
}
}
else
{
SaveDeck(false);
}
editedDeckName = string.Empty;
}
/// <summary>
/// ｶｽﾀﾑﾀﾞｲｱﾛｸﾞを非表示にします。
/// </summary>
/// <param name="dialog">ｶｽﾀﾑﾀﾞｲｱﾛｸﾞのｲﾝｽﾀﾝｽ</param>
/// <param name="settings">設定情報</param>
/// <returns><code>Task</code></returns>
public Task HideMetroDialogAsync(BaseMetroDialog dialog, MetroDialogSettings settings = null)
{
return(DialogCoordinator.HideMetroDialogAsync(this, dialog, settings));
}
private async void clickSwitch(Object obj)
{
switch (obj.ToString())
{
case "menu_editar":
if (_selectedItem != null)
{
GuardarMenuEnabled = true;
AgregarMenuEnabled = false;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = true;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = false;
AgregarVisible = true;
bandera_editar = true;
FocusText = true;
RFC = _selectedItem.Nombre;
Nombre = _selectedItem.Materno;
Direccion = _selectedItem.Sexo;
RazonSocial = _selectedItem.Paterno;
HomoClave = _selectedItem.Edad;
Contacto = _selectedItem.IsSelected.ToString();
Telefono = _selectedItem.Estatura;
}
else
{
bandera_editar = false;
var met = Application.Current.Windows[0] as MetroWindow;
await met.ShowMessageAsync("Validación", "Debe seleccionar una opcion.");
}
break;
case "menu_agregar":
AgregarVisible = true;
GuardarMenuEnabled = true;
AgregarMenuEnabled = false;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = true;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = false;
AgregarVisible = true;
bandera_editar = false;
FocusText = true;
LimpiarCampos();
break;
case "menu_guardar":
bool cont;
if (Contacto == "")
{
cont = true;
}
else
{
cont = false;
}
if (bandera_editar == false)
{
ListItems.Add(new Persona()
{
Edad = HomoClave,
Estatura = Telefono,
IsSelected = cont,
Materno = Nombre,
Paterno = RazonSocial,
Nombre = RFC,
Sexo = Direccion
});
}
else
{
SelectedItem.Edad = HomoClave;
SelectedItem.Estatura = Telefono;
SelectedItem.IsSelected = cont;
SelectedItem.Materno = Nombre;
SelectedItem.Paterno = RazonSocial;
SelectedItem.Nombre = RFC;
SelectedItem.Sexo = Direccion;
}
GuardarMenuEnabled = false;
AgregarMenuEnabled = true;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = false;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = true;
AgregarVisible = false;
SelectedItem = null;
SeleccionIndice = -1;
LimpiarCampos();
break;
case "menu_cancelar":
GuardarMenuEnabled = false;
AgregarMenuEnabled = true;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = false;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = true;
AgregarVisible = false;
SelectedItem = null;
SeleccionIndice = -1;
LimpiarCampos();
break;
case "menu_eliminar":
var metro = Application.Current.Windows[0] as MetroWindow;
if (_selectedItem != null)
{
var mySettings = new MetroDialogSettings()
{
AffirmativeButtonText = "Aceptar",
NegativeButtonText = "Cancelar",
AnimateShow = true,
AnimateHide = false
};
var result = await metro.ShowMessageAsync("Borrar", "¿Está seguro que desea borrar esto? [ " + 1 + " ]", MessageDialogStyle.AffirmativeAndNegative, mySettings);
if (result == MessageDialogResult.Affirmative)
{
var i = ListItems.IndexOf(_selectedItem);
if (i >= 0)
{
ListItems.RemoveAt(i);
var dialog = (BaseMetroDialog)metro.Resources["ConfirmacionDialog"];
await metro.ShowMetroDialogAsync(dialog);
await TaskEx.Delay(1500);
await metro.HideMetroDialogAsync(dialog);
//MENSAJE EXTERNO
//dialog = dialog.ShowDialogExternally();
//await TaskEx.Delay(1500);
//await dialog.RequestCloseAsync();
}
}
}
else
{
await metro.ShowMessageAsync("Validación", "Debe seleccionar una opcion");
}
SelectedItem = null;
SeleccionIndice = -1;
LimpiarCampos();
break;
case "menu_exportar":
SelectedItem = null;
SeleccionIndice = -1;
LimpiarCampos();
break;
case "menu_ayuda":
SelectedItem = null;
SeleccionIndice = -1;
LimpiarCampos();
break;
case "menu_salir":
SelectedItem = null;
SeleccionIndice = -1;
LimpiarCampos();
break;
}
if (_selectedItem == null)
{
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
}
}
private async void enviarEmail(object sender, RoutedEventArgs e)
{
SmtpClient smtpClient = new SmtpClient();
NetworkCredential basicCredential = new NetworkCredential("*****@*****.**", "humanbeing123");
MailMessage message = new MailMessage();
MailAddress fromAddress = new MailAddress("*****@*****.**");
smtpClient.Host = "smtp.gmail.com";
smtpClient.Port = 587;
//smtpClient.Port = 465;
smtpClient.DeliveryMethod = SmtpDeliveryMethod.Network;
smtpClient.UseDefaultCredentials = false;
smtpClient.EnableSsl = true;
smtpClient.Credentials = basicCredential;
smtpClient.Timeout = 500000;
message.From = fromAddress;
message.Subject = "Relatório de Execução de Roteiro";
//Set IsBodyHtml to true means you can send HTML email.
message.IsBodyHtml = true;
message.Body = this.gerarMensagemRelatorioHTML();
// message.Body = @"<h1>Relatório</h1></br>
//
// <h2>Sistema: " + selectedSistema.Nome + @"</h2></br>" +
// "<h2>Roteiro: " + this.SelectedSuite.Codigo.ToUpper() + @"</h2></br>";
// message.Body += @"<h5> Hora da Execução: " + this.SelectedSuite.horaExecucao.ToString() + "</h5></br>";
// message.Body += @"<h5> Tempo de Execução: " + this.SelectedSuite.tempoExecucao.ToString() + "</h5></br>";
// message.Body += @"<h5> Quantidade de Testes: " + this.SelectedSuite.PassosDoRoteiro.Count.ToString() + "</h5></br>";
// message.Body += @"<table style=' font-family: arial, sans-serif; border-collapse: collapse; width: 100%;'>
// <tr>
// <th style='border: 1px solid #dddddd;text-align: left;padding: 8px;'>Código</th>
// <th style='border: 1px solid #dddddd;text-align: left;padding: 8px;'>Nome</th>
// <th style='border: 1px solid #dddddd;text-align: left;padding: 8px;'>APR/TOTAL IE</th>
// <th style='border: 1px solid #dddddd;text-align: left;padding: 8px;'>APR/TOTAL FFOX</th>
// <th style='border: 1px solid #dddddd;text-align: left;padding: 8px;'>APR/TOTAL CHROME</th>
// <th style='border: 1px solid #dddddd;text-align: left;padding: 8px;'>APR/TOTAL EDGE</th>
// <th style='border: 1px solid #dddddd;text-align: left;padding: 8px;'>INFO</th>
// </tr>";
// //Create Zip File
// //using (var rar = File.OpenWrite(this.SelectedSuite.Codigo+".zip"))
// //{
// // using (var rarWriter = WriterFactory.Open(rar, ArchiveType.Zip, new CompressionInfo() { DeflateCompressionLevel = SharpCompress.Compressor.Deflate.CompressionLevel.BestCompression }))
// // {
// // foreach (var passo in this.SelectedSuite.PassosDoRoteiro)
// // {
// // rarWriter.Write(new FileInfo(passo.SelectedCase.CaminhoArquivoCTF).Name, new FileInfo(passo.SelectedCase.CaminhoArquivoCTF)) ;
// // }
// // }
// //}
// foreach (PassoDoRoteiro passo in this.SelectedSuite.PassosDoRoteiro)
// {
// message.Body += "<tr>";
// message.Body += "<td style='border: 1px solid #dddddd;text-align: left;padding: 8px;'>" + passo.SelectedCase.Codigo + "</td>";
// message.Body += "<td style='border: 1px solid #dddddd;text-align: left;padding: 8px;'>" + passo.SelectedCase.Nome + "</td>";
// message.Body += "<td style='border: 1px solid #dddddd;text-align: left;padding: 8px;'>" + passo.ie_stats + "</td>";
// message.Body += "<td style='border: 1px solid #dddddd;text-align: left;padding: 8px;'>" + passo.ffox_stats + "</td>";
// message.Body += "<td style='border: 1px solid #dddddd;text-align: left;padding: 8px;'>" + passo.chrome_stats + "</td>";
// message.Body += "<td style='border: 1px solid #dddddd;text-align: left;padding: 8px;'>" + passo.edge_stats + "</td>";
// message.Body += "<td style='border: 1px solid #dddddd;text-align: left;padding: 8px;'>" + passo.Obs + "</td>";
// message.Body += "</tr>";
// //Attachment anexo;
// //anexo = new Attachment(passo.SelectedCase.CaminhoArquivoCTF);
// //message.Attachments.Add(anexo);
// }
// //Attachment anexo;
// //anexo = new Attachment(this.SelectedSuite.Codigo + ".zip");
// //message.Attachments.Add(anexo);
// //message.Attachments.Add(anexo);
// message.Body += "</table>";
MetroDialogSettings st = new MetroDialogSettings();
st.AffirmativeButtonText = "Ok";
st.NegativeButtonText = "Cancelar";
string emailDest = await this.mainWindow.ShowInputAsync("Email", "Insira o EMAIL para envio do relatório", st);
if (!String.IsNullOrEmpty(emailDest))
{
message.To.Add(emailDest);
try
{
smtpClient.Send(message);
await this.mainWindow.ShowMessageAsync("Sucesso", "Mensagem Enviada para " + emailDest + ".");
//MessageBox.Show("Mensagem Enviada");
}
catch (Exception ex)
{
//Error, could not send the message
this.mainWindow.ShowMessageAsync("Erro", "Detalhes: " + ex.Message + ex.Source + ex.StackTrace);
}
}
else
{
await this.mainWindow.ShowMessageAsync("Erro", "Insira o email.");
}
}
public async Task <ProgressDialogController> ShowProgressAsync(string header, string message, MetroDialogSettings metroDialogSettings)
{
foreach (var window in Application.Current.Windows.OfType <MetroWindow>())
{
if (window.Name == "FormotsMainWindow")
{
window.MetroDialogOptions.ColorScheme = MetroDialogColorScheme.Accented;
return(await window.ShowProgressAsync(header, message, false, metroDialogSettings));
}
}
return(null);
}
public FolderSelectDialog(MetroWindow parentWindow, MetroDialogSettings settings) : base(parentWindow, settings)
{
InitializeComponent();
AffirmativeButton.Content = settings.AffirmativeButtonText;
NegativeButton.Content = settings.NegativeButtonText;
}
internal AutoCloseMessageDialog(MetroWindow parentWindow, MetroDialogSettings settings)
: base(parentWindow, settings)
{
InitializeComponent();
HandleVisibility(settings);
}
public MetroMessageBoxEventArgs(string title, string message, MetroDialogSettings dialogSettings = null)
{
Title = title;
Message = message;
DialogSettings = dialogSettings;
}
public Task <MessageDialogResult> ShowModal(string title, string message, MessageDialogStyle style = MessageDialogStyle.Affirmative, MetroDialogSettings settings = null)
{
return(this.Dispatcher.Invoke(() => this.ShowMessageAsync(title, message, style, settings)));
}
private async void clickSwitch(Object obj)
{
switch (obj.ToString())
{
case "buscar_articulo_medicamento":
SelectedItem = null;
SeleccionIndice = -1;
Cambio = string.Empty;
break;
case "menu_editar":
if (_selectedItem != null)
{
EditarVisible = true;
NuevoVisible = false;
Cambio = SelectedItem.Username;
GuardarMenuEnabled = true;
AgregarMenuEnabled = false;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = true;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = false;
AgregarVisible = true;
bandera_editar = true;
FocusText = true;
}
else
{
bandera_editar = false;
var met = Application.Current.Windows[0] as MetroWindow;
await met.ShowMessageAsync("Validación", "Debe seleccionar una opcion.");
}
break;
case "menu_agregar":
EditarVisible = false;
NuevoVisible = true;
GuardarMenuEnabled = true;
AgregarMenuEnabled = false;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = true;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = false;
AgregarVisible = true;
bandera_editar = false;
FocusText = true;
break;
case "menu_guardar":
if (bandera_editar == false)
{
ListItems.Add(new Usuario()
{
Username = Cambio, Password = "******"
});
}
else
{
SelectedItem.Username = Cambio;
}
EditarVisible = false;
NuevoVisible = false;
GuardarMenuEnabled = false;
AgregarMenuEnabled = true;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = false;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = true;
AgregarVisible = false;
SelectedItem = null;
SeleccionIndice = -1;
Cambio = string.Empty;
break;
case "menu_cancelar":
NuevoVisible = false;
GuardarMenuEnabled = false;
AgregarMenuEnabled = true;
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
CancelarMenuEnabled = false;
AyudaMenuEnabled = true;
SalirMenuEnabled = true;
ExportarMenuEnabled = true;
AgregarVisible = false;
SelectedItem = null;
SeleccionIndice = -1;
Cambio = string.Empty;
break;
case "menu_eliminar":
var metro = Application.Current.Windows[0] as MetroWindow;
if (_selectedItem != null)
{
var mySettings = new MetroDialogSettings()
{
AffirmativeButtonText = "Aceptar",
NegativeButtonText = "Cancelar",
AnimateShow = true,
AnimateHide = false
};
var result = await metro.ShowMessageAsync("Borrar", "¿Está seguro que desea borrar esto? [ " + SelectedItem.Username + " ]", MessageDialogStyle.AffirmativeAndNegative, mySettings);
if (result == MessageDialogResult.Affirmative)
{
var i = ListItems.IndexOf(_selectedItem);
if (i >= 0)
{
ListItems.RemoveAt(i);
var dialog = (BaseMetroDialog)metro.Resources["ConfirmacionDialog"];
await metro.ShowMetroDialogAsync(dialog);
await TaskEx.Delay(1500);
await metro.HideMetroDialogAsync(dialog);
//MENSAJE EXTERNO
//dialog = dialog.ShowDialogExternally();
//await TaskEx.Delay(1500);
//await dialog.RequestCloseAsync();
}
}
}
else
{
await metro.ShowMessageAsync("Validación", "Debe seleccionar una opcion");
}
SelectedItem = null;
SeleccionIndice = -1;
Cambio = string.Empty;
break;
case "menu_exportar":
SelectedItem = null;
SeleccionIndice = -1;
Cambio = string.Empty;
break;
case "menu_ayuda":
SelectedItem = null;
SeleccionIndice = -1;
Cambio = string.Empty;
break;
case "menu_salir":
PrincipalViewModel.SalirMenu();
break;
}
if (_selectedItem == null)
{
EliminarMenuEnabled = false;
EditarMenuEnabled = false;
}
}
private async void ChangeSettingsAction()
{
MovingFiles = true;
bool overwrite = false;
bool forceRestart = false;
string[] filesTargedLocation = Directory.GetFiles(LocationSelectedPath);
// Check if there are any settings files in the folder...
if (FilesContainsSettingsFiles(filesTargedLocation))
{
MetroDialogSettings settings = AppearanceManager.MetroDialog;
settings.AffirmativeButtonText = LocalizationManager.GetStringByKey("String_Button_Overwrite");
settings.NegativeButtonText = LocalizationManager.GetStringByKey("String_Button_Cancel");
settings.FirstAuxiliaryButtonText = LocalizationManager.GetStringByKey("String_Button_MoveAndRestart");
settings.DefaultButtonFocus = MessageDialogResult.FirstAuxiliary;
MessageDialogResult result = await dialogCoordinator.ShowMessageAsync(this, LocalizationManager.GetStringByKey("String_Header_Overwrite"), LocalizationManager.GetStringByKey("String_OverwriteSettingsInTheDestinationFolder"), MessageDialogStyle.AffirmativeAndNegativeAndSingleAuxiliary, AppearanceManager.MetroDialog);
if (result == MessageDialogResult.Negative)
{
MovingFiles = false;
return;
}
else if (result == MessageDialogResult.Affirmative)
{
overwrite = true;
}
else if (result == MessageDialogResult.FirstAuxiliary)
{
forceRestart = true;
}
}
// Try moving files (permissions, file is in use...)
try
{
await SettingsManager.MoveSettingsAsync(SettingsManager.GetSettingsLocation(), LocationSelectedPath, overwrite, filesTargedLocation);
Properties.Settings.Default.Settings_CustomSettingsLocation = LocationSelectedPath;
// Show the user some awesome animation to indicate we are working on it :)
await Task.Delay(2000);
}
catch (Exception ex)
{
MetroDialogSettings settings = AppearanceManager.MetroDialog;
settings.AffirmativeButtonText = LocalizationManager.GetStringByKey("String_Button_OK");
await dialogCoordinator.ShowMessageAsync(this, LocalizationManager.GetStringByKey("String_Header_Error") as string, ex.Message, MessageDialogStyle.Affirmative, settings);
}
LocationSelectedPath = string.Empty;
LocationSelectedPath = Properties.Settings.Default.Settings_CustomSettingsLocation;
if (forceRestart)
{
SettingsManager.ForceRestart = true;
CloseAction();
}
MovingFiles = false;
}
private async void ShowProgressDialog(object sender, RoutedEventArgs e)
{
var mySettings = new MetroDialogSettings()
{
NegativeButtonText = "Close now",
AnimateShow = false,
AnimateHide = false
};
TextVer = "radar.version";
string downloadToPath = Environment.CurrentDirectory;
string localVersion = Versions.LocalVersion(downloadToPath + "/radar.version");
string remoteURL = "https://lafkomods.ru/update/radar/";
string remoteVersion = Versions.RemoteVersion(remoteURL + "radar.version");
string remoteFile = remoteURL + remoteVersion + ".zip";
if (localVersion != remoteVersion)
{
Button1.IsEnabled = false;
string filePath = Versions.CreateTargetLocation(downloadToPath, remoteVersion);
var controller = await this.ShowProgressAsync("Please wait...", "We are finding some radar!", settings : mySettings);
controller.SetIndeterminate();
await System.Threading.Tasks.Task.Delay(2000);
Uri remoteURI = new Uri(remoteFile);
WebClient downloader = new WebClient();
downloader.DownloadProgressChanged += new DownloadProgressChangedEventHandler(wb_DownloadProgressChanged);
downloader.DownloadFileCompleted += new AsyncCompletedEventHandler(downloader_DownloadFileCompleted);
downloader.DownloadFileCompleted += wc_DownloadFileCompleted2;
downloader.DownloadFileAsync(remoteURI, filePath + ".zip", new string[] { remoteVersion, downloadToPath, "update.txt" });
controller.SetCancelable(false);
double i = 1.0;
while (i < 99.9)
{
double val = progressBar1.Value;
controller.SetProgress(val / 100);
controller.SetMessage("Downloading radar: " + val + "%...");
i = val;
await System.Threading.Tasks.Task.Delay(500);
}
await controller.CloseAsync();
if (controller.IsCanceled)
{
await this.ShowMessageAsync("No radar!", "You stopped downloading radar!");
}
else
{
MessageDialogResult result = await this.ShowMessageAsync("Downloading Radar finished!", "Clear the directory from zip files?", MessageDialogStyle.AffirmativeAndNegative);
if (result == MessageDialogResult.Affirmative)
{
var v = Directory.GetFiles(Environment.CurrentDirectory, "*.zip", SearchOption.AllDirectories);
foreach (var s in v)
{
File.Delete(s);
}
}
}
}
}
public CustomDialog(MetroWindow parentWindow, MetroDialogSettings settings)
: base(parentWindow, settings)
{
}
private async void AddMultipleAlarms()
{
var mySettings = new MetroDialogSettings()
{
AffirmativeButtonText = "Yes",
NegativeButtonText = "No",
FirstAuxiliaryButtonText = "Cancel",
AnimateHide = true,
AnimateShow = true,
ColorScheme = MetroDialogColorScheme.Theme
};
var result = (new ViewModelLocator()).Main.DialogBox("Duplication", "Replace if there are alarms at the same time exist", mySettings, MessageDialogStyle.AffirmativeAndNegativeAndSingleAuxiliary);
if (await result != MessageDialogResult.FirstAuxiliary)
{
if (await result == MessageDialogResult.Affirmative)
{
while (MultipleAlarmsStartTime.TimeOfDay <= MultipleAlarmsEndTime.TimeOfDay)
{
var alarm = new Alarm();
alarm.Time = new DateTime(MultipleAlarmsStartTime.Ticks);
alarm.Sound1 = SelectedSound;
if (SelectedItem.Alarms.Any(z => Convert.ToDateTime(z.Time) == Convert.ToDateTime(alarm.Time)))
{
var alarmtodelete =
SelectedItem.Alarms.First(z => Convert.ToDateTime(z.Time) == Convert.ToDateTime(alarm.Time));
_dataService.DeleteAlarm(alarmtodelete);
}
SelectedItem.Alarms.Add(alarm);
MultipleAlarmsStartTime = MultipleAlarmsStartTime.AddMinutes(Interval);
}
}
else
{
while (MultipleAlarmsStartTime.TimeOfDay <= MultipleAlarmsEndTime.TimeOfDay)
{
var alarm = new Alarm();
alarm.Time = new DateTime(MultipleAlarmsStartTime.Ticks);
alarm.Sound1 = SelectedSound;
if (!SelectedItem.Alarms.Any(z => Convert.ToDateTime(z.Time) == Convert.ToDateTime(alarm.Time)))
{
SelectedItem.Alarms.Add(alarm);
}
MultipleAlarmsStartTime = MultipleAlarmsStartTime.AddMinutes(Interval);
}
}
}
_dataService.SaveAll();
(new ViewModelLocator()).Main.NewAlarmFlyoutStatus = false;
(new ViewModelLocator()).Main.StartScheduler();
}
