public void SelectedOptionsShouldValidateEmptyValuesCorrectly()
{
//Arrange
var options = new SelectedOptions();
var localizer = new Mock <IViewLocalizer>();
localizer.SetupGet(l => l["fieldIsRequiredLabel"]).Returns(new LocalizedHtmlString("fieldIsRequiredLabel", "This field is required my friend!"));
var serviceProvider = new Mock <IServiceProvider>();
serviceProvider.Setup(c => c.GetService(typeof(IViewLocalizer))).Returns(localizer.Object);
var context = new ValidationContext(options, serviceProvider.Object, null);
//Act
var res = options.Validate(context);
//Assert
Assert.Collection(res,
(v) => {
Assert.Equal("SpaceId", v.MemberNames.First());
Assert.Equal("This field is required my friend!", v.ErrorMessage);
},
(v) => {
Assert.Equal("AccessToken", v.MemberNames.First());
Assert.Equal("This field is required my friend!", v.ErrorMessage);
},
(v) => {
Assert.Equal("PreviewToken", v.MemberNames.First());
Assert.Equal("This field is required my friend!", v.ErrorMessage);
}
);
}
public SelectElement(IWebElement element, IWebDriver driver) : base(element, driver)
{
if (element.TagName == "select")
{
OldStyleSelect = new OpenQA.Selenium.Support.UI.SelectElement(element);
LazyAvailableOptions = new Lazy <IList <IWebElement> >(() => OldStyleSelect.Options);
LazySelectedOptions = new Lazy <IList <IWebElement> >(() => OldStyleSelect.AllSelectedOptions);
}
else
{
var listId = element.GetAttribute("list");
if (string.IsNullOrWhiteSpace(listId))
{
throw new Exception("The {element.TagName} is neither a select element nor an element with a list attribute");
}
LazyAvailableOptions = new Lazy <IList <IWebElement> >(() => driver.FindElements(By.XPath($"//datalist[@id='{listId}']/option")));
LazySelectedOptions = new Lazy <IList <IWebElement> >(() => new List <IWebElement>());
var value = element.GetAttribute("value");
if (!string.IsNullOrWhiteSpace(value))
{
var selected = AvailableOptions.Where(o => o.GetAttribute("value") == value);
if (selected.None())
{
throw new Exception($"element with list:{listId} and value:{value} did not find any mathching options in the {AvailableOptions.Count()} options");
}
if (selected.Many())
{
throw new Exception($"element with list:{listId} and value:{value} found {selected.Count()} mathching options in the {AvailableOptions.Count()} options");
}
SelectedOptions.Add(selected.First());
}
}
}
public void SelectedOptionsShouldValidate404Correctly()
{
//Arrange
var notfoundError = @"{
""sys"": {
""type"": ""Error"",
""id"": ""NotFound""
},
""message"": ""The resource could not be found."",
""details"": {
""sys"": {
""type"": ""Space""
}
},
""requestId"": ""435""
}";
var options = new SelectedOptions();
options.AccessToken = "Faulty";
options.PreviewToken = "Faulty!";
options.SpaceId = "Some space";
var localizer = new Mock <IViewLocalizer>();
localizer.SetupGet(l => l["deliveryKeyInvalidLabel"]).Returns(new LocalizedHtmlString("deliveryKeyInvalidLabel", "Wrong delivery key!"));
localizer.SetupGet(l => l["previewKeyInvalidLabel"]).Returns(new LocalizedHtmlString("previewKeyInvalidLabel", "Wrong preview key!"));
localizer.SetupGet(l => l["spaceOrTokenInvalid"]).Returns(new LocalizedHtmlString("spaceOrTokenInvalid", "Wrong space id!"));
localizer.SetupGet(l => l["somethingWentWrongLabel"]).Returns(new LocalizedHtmlString("somethingWentWrongLabel", "Error!"));
var serviceProvider = new Mock <IServiceProvider>();
serviceProvider.Setup(c => c.GetService(typeof(IViewLocalizer))).Returns(localizer.Object);
var handler = new FakeMessageHandler();
handler.Responses.Enqueue(new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.NotFound, Content = new StringContent(notfoundError)
});
handler.Responses.Enqueue(new HttpResponseMessage()
{
StatusCode = System.Net.HttpStatusCode.NotFound, Content = new StringContent(notfoundError)
});
var httpClient = new HttpClient(handler);
serviceProvider.Setup(c => c.GetService(typeof(HttpClient))).Returns(httpClient);
var context = new ValidationContext(options, serviceProvider.Object, null);
//Act
var res = options.Validate(context);
//Assert
Assert.Collection(res,
(v) => {
Assert.Equal("SpaceId", v.MemberNames.First());
Assert.Equal("Wrong space id!", v.ErrorMessage);
},
(v) => {
Assert.Equal("SpaceId", v.MemberNames.First());
Assert.Equal("Wrong space id!", v.ErrorMessage);
}
);
}
public MainViewModel()
{
DownloadDepotTools = new CommandHandler {
Action = OnDownloadDepotTools
};
UpdateDepotTools = new CommandHandler {
Action = OnUpdateDepotTools
};
BrowseSource = new CommandHandler {
Action = OnBrowseSource
};
DownloadSource = new CommandHandler {
Action = OnDownloadSource
};
UpdateSource = new CommandHandler {
Action = OnUpdateSource
};
GetOptionsAvailable = new CommandHandler {
Action = OnUpdateOptions
};
OpenReadMe = new CommandHandler {
Action = OnOpenReadMe
};
ExploreConfiguration = new CommandHandler {
Action = OnExploreConfiguration
};
ConfigureBuild = new CommandHandler {
Action = OnConfigureBuild
};
BrowseBuildFolder = new CommandHandler {
Action = OnBrowseBuild
};
MoveAvailable = new CommandHandler {
Action = OnMoveAvailable
};
MoveSelected = new CommandHandler {
Action = OnMoveSelected
};
BrowseWindowsKit = new CommandHandler {
Action = OnBrowseWindowsKit
};
BuildV8 = new CommandHandler {
Action = OnBuildV8
};
// The available options are those that are not selected
foreach (var option in Config.BuildOptions)
{
if (option.Selected)
{
SelectedOptions.Add(option);
}
else
{
AvailableOptions.Add(option);
}
}
InvokePropertyChanged(nameof(Config));
}
private void RemoveItemClick(object sender, Windows.UI.Xaml.Input.TappedRoutedEventArgs e)
{
string text = ((Button)sender).Tag.ToString();
SelectedOptions = SelectedOptions.Where(x => x != text).ToList();
SetValue(SelectedOptionsProperty, this.SelectedOptions);
this.RefreshList();
}
public void Refresh()
{
var opts = SelectedOptions.Split(',');
var searchName = opts.Contains("Name");
var searchLastNames = opts.Contains("Last Names");
var searchIP = opts.Contains("IP");
var searchGuid = opts.Contains("Guid");
var searchNotes = opts.Contains("Notes");
var searchComment = opts.Contains("Comment");
IEnumerable <PlayerDto> result;
if (!string.IsNullOrEmpty(Filter))
{
result = _playerRepository.GetPlayers(x =>
(searchGuid && (x.GUID == Filter))
||
(searchComment && x.Comment.Contains(Filter))
||
(searchName && x.Name.Contains(Filter))
||
(searchNotes && x.Notes.Any(y => y.Text.Contains(Filter)))
||
(searchIP && x.LastIp.Contains(Filter))
||
(searchLastNames && x.PlayerHistory.Any(y => y.Name.Contains(Filter))));
}
else
{
result = _playerRepository.GetAllPlayers();
}
var r = result.Select(x => new PlayerView
{
Id = x.Id,
Comment = x.Comment,
Guid = x.GUID,
Name = x.Name,
LastIp = x.LastIp,
LastSeen = x.LastSeen
}).OrderBy(x => x.Name).ToList();
foreach (var playerView in r)
{
playerView.LastSeen = playerView.LastSeen.UtcToLocalFromSettings();
}
PlayerCount = r.Count;
Players = r;
OnPropertyChanged(nameof(Players));
}
/// <summary>
/// Creates a new instance of <see cref="HotstringSendMethodSelectedOptions"/> populated with the
/// values in <paramref name="Options"/>
/// </summary>
/// <param name="Options">The Array of Enum Values use to populate the instance</param>
/// <returns>
/// Instance of <see cref="HotstringSendMethodSelectedOptions"/>. If <paramref name="Options"/> is null
/// then return instance will have no values.
/// </returns>
public new HotstringSendMethodSelectedOptions FromArray(Enums.HotStringSendEnum[] Options)
{
var so = SelectedOptions <Enums.HotStringSendEnum> .FromArray(Options);
HotstringSendMethodSelectedOptions hs = new HotstringSendMethodSelectedOptions();
hs.Keys = so.Keys;
hs.Options = so.Options;
return(hs);
}
private void AddSelectedOption(TOption opt, string input)
{
if (SelectedOptions.ContainsKey(opt))
{
SelectedOptions[opt] = input;
}
else
{
SelectedOptions.Add(opt, input);
}
}
public FormFieldViewModel(FormField field, string[] languageCodes) : this()
{
var names = field.GetNames(true);
var values = field.GetValues(false);
IEnumerable <Option> options = typeof(OptionsField).IsAssignableFrom(field.GetType()) ? ((OptionsField)field).Options : new List <Option>();
foreach (var name in names)
{
if (languageCodes.Contains(name.LanguageCode))
{
Names.Add(name.LanguageCode, name.Value);
}
}
foreach (var value in values)
{
if (languageCodes.Contains(value.LanguageCode))
{
if (Values.ContainsKey(value.LanguageCode))
{
Values = new Dictionary <string, string>();
ValuesList.Add(Values);
Values.Add(value.LanguageCode, value.Value);
}
else
{
Values.Add(value.LanguageCode, value.Value);
}
}
}
foreach (string code in languageCodes)
{
SelectedOptions.Add(code, new List <string>());
}
foreach (var option in options)
{
if (option.Selected)
{
foreach (var optionVal in option.Value)
{
if (languageCodes.Contains(optionVal.LanguageCode))
{
SelectedOptions[optionVal.LanguageCode].Add(optionVal.Value);
}
}
}
}
}
public void RemoveSelection(string key)
{
var option = ItemsSource.FirstOrDefault(x => x.Key == key);
if (option == null)
{
return;
}
CascadedEditContext?.NotifyFieldChanged(FieldIdentifier);
if (MultiSelect)
{
if (!SelectedOptions.Contains(option))
{
throw new Exception("This option was not already selected.");
}
if (OnChange.HasDelegate)
{
OnChange.InvokeAsync(new BFUDropdownChangeArgs(option, false));
}
SelectedOptions = SelectedOptions.Where(x => x != option).ToList();
if (SelectedOptionsChanged.HasDelegate)
{
SelectedOptionsChanged.InvokeAsync(SelectedOptions);
}
}
else
{
if (SelectedOption != null)
{
SelectedOption = null;
if (OnChange.HasDelegate)
{
OnChange.InvokeAsync(new BFUDropdownChangeArgs(option, false));
}
if (SelectedOptionChanged.HasDelegate)
{
SelectedOptionChanged.InvokeAsync(SelectedOption);
}
}
}
StateHasChanged();
}
/// <summary>
/// Removes the option from specified position.
/// </summary>
/// <param name="index">Position of option to be removed.</param>
public void Remove(int index)
{
var options = Options;
if (index >= 0 && index < options.Length)
{
var optionToRemove = options[index];
RemoveChild(optionToRemove);
if (SelectedOptions.IndexOf(optionToRemove) != -1)
{
SelectedOptions.Remove(optionToRemove);
if (!Multiple && options.Length > 0)
{
SelectedOptions.Add(options[0]);
}
}
}
}
private void AddNewItemClick(object sender, Windows.UI.Xaml.Input.TappedRoutedEventArgs e)
{
// validate
if (textBox.Text == "")
{
return;
}
if (SelectedOptions.Contains(textBox.Text))
{
this.ShowError("Opties moeten uniek zijn.");
return;
}
SelectedOptions.Add(textBox.Text);
this.HideError();
SetValue(SelectedOptionsProperty, this.SelectedOptions);
textBox.Text = "";
this.RefreshList();
}
public SelectElement(IWebElement element, IWebDriver driver) : base(element, driver)
{
if (element.TagName == "select")
{
OldStyleSelect = new OpenQA.Selenium.Support.UI.SelectElement(element);
LazyAvailableOptions = new Lazy <IList <IWebElement> >(() => OldStyleSelect.Options);
LazySelectedOptions = new Lazy <IList <IWebElement> >(() => OldStyleSelect.AllSelectedOptions);
}
else
{
var listId = element.GetAttribute("list");
LazyAvailableOptions = new Lazy <IList <IWebElement> >(() => driver.FindElements(By.XPath($"//datalist[@id='{listId}']/option")));
LazySelectedOptions = new Lazy <IList <IWebElement> >(() => new List <IWebElement>());
var value = element.GetAttribute("value");
if (!string.IsNullOrWhiteSpace(value))
{
SelectedOptions.Add(AvailableOptions.First(o => o.GetAttribute("value") == value));
}
}
}
/// <summary>
/// Binds the Send type Drop down list Filtering by Hotstring Type
/// </summary>
public void BindSendType()
{
if (m_HotStringValue == null)
{
return;
}
SelectedOptions <HotStringSendEnum> SendOptions = new SelectedOptions <HotStringSendEnum>();
if (this.HotStringValue.type == hotstringType.Inline)
{
EnumRule <HotStringSendEnum> SendExclude = new EnumRule <HotStringSendEnum>();
SendExclude.Add(HotStringSendEnum.None);
SendTypes = HotstringSendMethodMap.Instance.ToBindingList(SendOptions, SendExclude);
}
else
{
SendTypes = HotstringSendMethodMap.Instance.ToBindingList(SendOptions);
}
ddlSend.DataSource = null;
ddlSend.Items.Clear();
ddlSend.DisplayMember = "DisplayValue";
ddlSend.ValueMember = "Key";
ddlSend.DataSource = SendTypes;
if (ddlSend.Items.Count > 0)
{
ddlSend.SelectedIndex = 0;
for (int i = 0; i < ddlSend.Items.Count; i++)
{
AhkKeyMapAhkMapValue mv = (AhkKeyMapAhkMapValue)ddlSend.Items[i];
if (mv.Selected == true)
{
ddlSend.SelectedIndex = i;
break;
}
}
}
}
/// <summary>
/// Gets a Instance of <see cref="HotstringSendMethodSelectedOptions"/> From a String value
/// </summary>
/// <param name="s">The String to parse for values</param>
/// <returns>
/// Instance of <see cref="HotstringSendMethodSelectedOptions"/> if Parse succeeded; Otherwise, null.
/// </returns>
/// <exception cref="ArgumentNullException"></exception>
public new static HotstringSendMethodSelectedOptions Parse(string s)
{
if (string.IsNullOrEmpty(s))
{
throw new ArgumentNullException();
}
try
{
// all chars except for `n and `t are single chars
var opt = new HotstringSendMethodSelectedOptions();
var so = SelectedOptions <Enums.HotStringSendEnum> .Parse(s);
opt.Keys = so.Keys;
opt.Options = so.Options;
return(opt);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Adds new 'OPTION' nodes to the dropdown. Other nodes types are ignored.
/// </summary>
public override Node AppendChild(Node node)
{
if (node is HtmlOptionElement option)
{
if (!Multiple)
{
if (Options.Length == 0 || option.Selected)
{
SelectedOptions.Clear();
SelectedOptions.Add(option);
}
}
else
{
if (option.Selected)
{
SelectedOptions.Add(option);
}
}
}
return(base.AppendChild(node));
}
/// <summary>
/// Invokes this middleware.
/// </summary>
/// <param name="context">The HttpContext of the request to extract breadcrumbs from.</param>
/// <returns></returns>
public async Task Invoke(HttpContext context)
{
var query = context.Request.Query;
if (query.ContainsKey("space_id") && query.ContainsKey("preview_token") && query.ContainsKey("delivery_token"))
{
var currentOptions = new ContentfulOptions();
currentOptions.DeliveryApiKey = query["delivery_token"];
currentOptions.SpaceId = query["space_id"];
currentOptions.PreviewApiKey = query["preview_token"];
currentOptions.UsePreviewApi = query.ContainsKey("api") && query["api"] == "cpa";
currentOptions.MaxNumberOfRateLimitRetries = _manager.Options.MaxNumberOfRateLimitRetries;
currentOptions.ResolveEntriesSelectively = _manager.Options.ResolveEntriesSelectively;
currentOptions.ManagementApiKey = _manager.Options.ManagementApiKey;
var validateableOptions = new SelectedOptions
{
AccessToken = currentOptions.DeliveryApiKey,
PreviewToken = currentOptions.PreviewApiKey,
SpaceId = currentOptions.SpaceId
};
var validationContext = new ValidationContext(validateableOptions, context.RequestServices, null);
var validationResult = validateableOptions.Validate(validationContext);
if (validationResult.Any())
{
var modelStateErrors = new List <ModelStateError>();
foreach (var result in validationResult)
{
foreach (var member in result.MemberNames)
{
modelStateErrors.Add(new ModelStateError {
ErrorMessage = result.ErrorMessage, Key = member
});
}
}
context.Session.SetString("SettingsErrors", JsonConvert.SerializeObject(modelStateErrors));
context.Session.SetString("SettingsErrorsOptions", JsonConvert.SerializeObject(validateableOptions));
context.Response.Redirect("/settings");
context.Response.Headers.Add("Cache-Control", "no-cache, no-store");
context.Response.Headers.Add("Pragma", "no-cache");
return;
}
else
{
context.Session.SetString(nameof(ContentfulOptions), JsonConvert.SerializeObject(currentOptions));
}
}
else if (query.ContainsKey("api"))
{
var currentOptions = new ContentfulOptions
{
UsePreviewApi = query["api"] == "cpa",
DeliveryApiKey = _manager.Options.DeliveryApiKey,
SpaceId = _manager.Options.SpaceId,
PreviewApiKey = _manager.Options.PreviewApiKey,
MaxNumberOfRateLimitRetries = _manager.Options.MaxNumberOfRateLimitRetries,
ResolveEntriesSelectively = _manager.Options.ResolveEntriesSelectively,
ManagementApiKey = _manager.Options.ManagementApiKey
};
context.Session.SetString(nameof(ContentfulOptions), JsonConvert.SerializeObject(currentOptions));
}
if (query.ContainsKey("editorial_features") && string.Equals(query["editorial_features"], "enabled", StringComparison.InvariantCultureIgnoreCase))
{
context.Session.SetString("EditorialFeatures", "Enabled");
}
else if (query.ContainsKey("editorial_features"))
{
context.Session.SetString("EditorialFeatures", "Disabled");
}
await _next(context);
}
private async void OnUpdateOptions()
{
try
{
EnableButtons(false);
var workingFolder = Path.Combine(Config.SourceFolder, "v8");
var configFolder = (Application.Current as App).ConfigFolder;
var genFolder = Path.Combine(configFolder, "Downloads", "out.gn", "defaults");
var argsFileName = Path.Combine(configFolder, "Downloads", "gn_defaults.txt");
if (!Directory.Exists(workingFolder))
{
MessageBox.Show($"You must select an existing V8 source folder for the depot_tools to be able to produce a list "
+ "of available compiler options", $"V8 folder not found - '{workingFolder}'");
StatusText = "Updating build options failed";
return;
}
if (Directory.Exists(genFolder))
{
try
{
FileSystem.DeleteDirectory(genFolder, UIOption.AllDialogs, RecycleOption.SendToRecycleBin);
}
catch (Exception)
{
MessageBox.Show($"Cannot delete '{genFolder}'; is that folder open in another program?"
, $"Building V8 failed");
StatusText = $"failed to delete '{genFolder}'";
return;
}
}
var batch = new BatchFile
{
WorkingDirectory = workingFolder,
Model = this,
Title = $"retrieving the list of available build options",
};
if (!CheckPython(batch.PythonFileName))
{
return;
}
// batch.Commands.Add($"call python tools\\dev\\v8gen.py gen -b {Config.BuildConfiguration} \"{genFolder}\" --no-goma");
var gnFileName = Path.Combine(Config.DepotToolsFolder, "gn.py");
batch.Commands.Add($"\"{batch.PythonFileName}\" \"{gnFileName}\" gen \"{genFolder}\"");
batch.Commands.Add($"\"{batch.PythonFileName}\" \"{gnFileName}\" args \"{genFolder}\" --list >{argsFileName}");
StatusText = batch.Title;
StatusText = await batch.Run();
//var installer = CreateInstaller();
//StatusText = "Extracting build options";
//installer.WorkingDirectory = Path.Combine(Config.SourceFolder, "v8");
//installer.Arguments = $"/k title Generating a list of build options & gn gen \"{genFolder}\" & gn args \"{genFolder}\" --list >{argsFileName}";
//await Task.Run(() => Process.Start(installer).WaitForExit());
var existingOptions = new Dictionary <string, BuildOption>(StringComparer.OrdinalIgnoreCase);
foreach (var option in Config.BuildOptions)
{
existingOptions[option.Name] = option;
}
AvailableOptions.Clear();
SelectedOptions.Clear();
StatusText = "Parsing build options";
Config.BuildOptions.Clear();
var lines = File.ReadAllLines(argsFileName);
BuildOption currentOption = null;
OptionParserState state = OptionParserState.None;
StringBuilder descriptionBuilder = null;
for (var ii = 0; ii < lines.Length; ++ii)
{
var line = lines[ii];
switch (state)
{
case OptionParserState.None:
case OptionParserState.Name:
descriptionBuilder = new StringBuilder();
var name = line.Trim();
if (existingOptions.TryGetValue(name, out currentOption))
{
existingOptions.Remove(name);
}
else
{
currentOption = new Configuration.BuildOption
{
Name = line
};
}
if (currentOption.Selected)
{
SelectedOptions.Add(currentOption);
}
else
{
AvailableOptions.Add(currentOption);
}
Config.BuildOptions.Add(currentOption);
state = OptionParserState.Current;
break;
case OptionParserState.Current:
currentOption.Default = line.Split('=')[1].Trim();
state = OptionParserState.From;
break;
case OptionParserState.From:
state = OptionParserState.Blank;
break;
case OptionParserState.Blank:
state = OptionParserState.Description;
break;
case OptionParserState.Description:
if (!string.IsNullOrEmpty(line) && line[0] != ' ')
{
--ii; // Reparse this line, it's the next name
currentOption.Description = descriptionBuilder.ToString().Trim();
state = OptionParserState.Name;
}
else
{
descriptionBuilder.Append(' ');
descriptionBuilder.Append(line.Trim());
}
break;
}
}
if (currentOption != null && descriptionBuilder != null && (descriptionBuilder.Length > 0))
{
currentOption.Description = descriptionBuilder.ToString();
}
StatusText = "Ready";
}
finally
{
EnableButtons(true);
}
}
/// <summary>
/// Creates a List of <see cref="AhkKeyMapAhkMapValue"/> objects representing all the Value
/// in <see cref="EndCharsEnum"/>. The List is Sorted Based upon <see cref="AhkKeyMapAhkMapValue.Sort"/>
/// </summary>
/// <param name="SelectedValues">
/// Instance of <see cref="EndCharsSelectedOptions"/>. Each value in SelectedValues will set the
/// corresponding <see cref="AhkKeyMapAhkMapValue.Selected"/> to true;
/// </param>
/// <returns>
/// List of <see cref="AhkKeyMapAhkMapValue"/>
/// </returns>
/// <remarks>
/// <see cref="AhkKeyMapAhkMapValue.Parent"/> is set to the List.
/// </remarks>
public override List <AhkKeyMapAhkMapValue> ToList(SelectedOptions <EndCharsEnum> SelectedValues)
{
return(base.ToList(SelectedValues));
}
public void AddSelection(string key)
{
var option = ItemsSource.FirstOrDefault(x => x.Key == key);
if (option == null)
{
return;
}
if (MultiSelect)
{
if (SelectedOptions.Contains(option))
{
throw new Exception("This option was already selected somehow.");
}
if (OnChange.HasDelegate)
{
OnChange.InvokeAsync(new BFUDropdownChangeArgs(option, true));
}
SelectedOptions = SelectedOptions.Append(option).ToList();
if (SelectedOptionsChanged.HasDelegate)
{
SelectedOptionsChanged.InvokeAsync(SelectedOptions);
}
//if (SelectedKeys.Contains(key))
// throw new Exception("This key was already selected.");
//if (OnChange.HasDelegate)
// OnChange.InvokeAsync(new BFUDropdownChangeArgs(key, true));
//SelectedKeys.Add(key);
//if (SelectedKeysChanged.HasDelegate)
// SelectedKeysChanged.InvokeAsync(SelectedKeys);
}
else
{
if (SelectedOption != option)
{
SelectedOption = option;
if (OnChange.HasDelegate)
{
OnChange.InvokeAsync(new BFUDropdownChangeArgs(option, true));
}
if (SelectedOptionChanged.HasDelegate)
{
SelectedOptionChanged.InvokeAsync(SelectedOption);
}
}
isOpen = false;
//if (SelectedKey!= key)
//{
// SelectedKey = key;
// if (OnChange.HasDelegate)
// OnChange.InvokeAsync(new BFUDropdownChangeArgs(key, true));
// if (SelectedKeyChanged.HasDelegate)
// SelectedKeyChanged.InvokeAsync(SelectedKey);
//}
//isOpen = false;
}
StateHasChanged();
}
public void RemoveSelection(string key)
{
var option = ItemsSource.FirstOrDefault(x => x.Key == key);
if (option == null)
{
return;
}
if (MultiSelect)
{
if (!SelectedOptions.Contains(option))
{
throw new Exception("This option was not already selected.");
}
if (OnChange.HasDelegate)
{
OnChange.InvokeAsync(new BFUDropdownChangeArgs(option, false));
}
SelectedOptions = SelectedOptions.Where(x => x != option).ToList();
if (SelectedOptionsChanged.HasDelegate)
{
SelectedOptionsChanged.InvokeAsync(SelectedOptions);
}
//if (!SelectedKeys.Contains(key))
// throw new Exception("This key was not already selected.");
//if (OnChange.HasDelegate)
// OnChange.InvokeAsync(new BFUDropdownChangeArgs(key, false));
//SelectedKeys.Remove(key); //this used to be following the next command. A bug? I moved it here...
//if (SelectedKeysChanged.HasDelegate)
// SelectedKeysChanged.InvokeAsync(SelectedKeys);
}
else
{
if (SelectedOption != null)
{
SelectedOption = null;
if (OnChange.HasDelegate)
{
OnChange.InvokeAsync(new BFUDropdownChangeArgs(option, false));
}
if (SelectedOptionChanged.HasDelegate)
{
SelectedOptionChanged.InvokeAsync(SelectedOption);
}
}
//if (SelectedKey != null)
//{
// SelectedKey = null;
// if (OnChange.HasDelegate)
// OnChange.InvokeAsync(new BFUDropdownChangeArgs(key, false));
// if (SelectedKeyChanged.HasDelegate)
// SelectedKeyChanged.InvokeAsync(SelectedKey);
//}
}
StateHasChanged();
}
protected void Page_Load(object sender, EventArgs e)
{
if (CustomOptions != null)
{
SelectedOptions = new List <OptionItem>();
}
else
{
SelectedOptions = null;
return;
}
int idx = 0;
foreach (Control ctrl in _controls)
{
if (ctrl is DropDownList)
{
int id = Convert.ToInt32(((DropDownList)ctrl).SelectedValue);
SelectedOptions.Add(id > 0 ? CustomOptions[idx].Options.WithId(id) : null);
idx++;
}
else if (ctrl is RadioButtonList)
{
int id = Convert.ToInt32(((RadioButtonList)ctrl).SelectedValue);
SelectedOptions.Add(id > 0 ? CustomOptions[idx].Options.WithId(id) : null);
idx++;
}
else if (ctrl is CheckBox)
{
if (((CheckBox)ctrl).Checked)
{
CustomOptions[idx].Options[0].Title = Resource.Client_UserControls_CustomOptions_Yes;
SelectedOptions.Add(CustomOptions[idx].Options[0]);
}
else
{
if (CustomOptions[idx].IsRequired)
{
CustomOptions[idx].Options[0].Title = Resource.Client_UserControls_CustomOptions_No;
CustomOptions[idx].Options[0].PriceBc = 0;
SelectedOptions.Add(CustomOptions[idx].Options[0]);
}
else
{
SelectedOptions.Add(null);
}
}
idx++;
}
else if (ctrl is TextBox)
{
if (((TextBox)ctrl).TextMode == TextBoxMode.MultiLine)
{
if (string.IsNullOrEmpty(((TextBox)ctrl).Text))
{
SelectedOptions.Add(null);
if (CustomOptions[idx].IsRequired)
{
IsValid = false;
}
}
else
{
CustomOptions[idx].Options = new List <OptionItem>();
var opt = new OptionItem {
Title = ((TextBox)ctrl).Text
};
CustomOptions[idx].Options.Add(opt);
SelectedOptions.Add(CustomOptions[idx].Options[0]);
}
idx++;
}
else
{
if (string.IsNullOrEmpty(((TextBox)ctrl).Text))
{
SelectedOptions.Add(null);
if (CustomOptions[idx].IsRequired)
{
IsValid = false;
}
if (ShowValidation)
{
((TextBox)ctrl).CssClass = "valid-required group-cOptions";
}
}
else
{
CustomOptions[idx].Options = new List <OptionItem>();
var opt = new OptionItem {
Title = ((TextBox)ctrl).Text
};
CustomOptions[idx].Options.Add(opt);
SelectedOptions.Add(CustomOptions[idx].Options[0]);
}
idx++;
}
}
}
}
