protected override bool TryParseValueFromString(string value, [System.Diagnostics.CodeAnalysis.MaybeNullWhen(false)] out TItem result, [System.Diagnostics.CodeAnalysis.NotNullWhen(false)] out string validationErrorMessage)
{
Console.WriteLine($"TryParseValueFromString {value}");
// Let's Blazor convert the value for us
if (BindConverter.TryConvertTo(value, System.Globalization.CultureInfo.CurrentCulture, out TItem parsedValue))
{
result = parsedValue;
validationErrorMessage = null;
return(true);
}
result = default;
validationErrorMessage = $"The {FieldIdentifier.FieldName} field is not valid.";
return(false);
}
static bool TryParseDateTime(string value, out TValue result)
{
var success = BindConverter.TryConvertToDateTime(value, cultureInfoStatic, DateFormat, out var parsedValue);
if (success)
{
result = (TValue)(object)parsedValue;
return(true);
}
else
{
result = default;
return(false);
}
}
/// <summary>
///
/// </summary>
/// <param name="value"></param>
/// <param name="result"></param>
/// <param name="validationErrorMessage"></param>
/// <returns></returns>
protected override bool TryParseValueFromString(string?value, [MaybeNullWhen(false)] out TValue result, [NotNullWhen(false)] out string?validationErrorMessage)
{
var ret = false;
validationErrorMessage = null;
if (BindConverter.TryConvertTo <TValue>(value, CultureInfo.InvariantCulture, out result))
{
ret = true;
}
else
{
validationErrorMessage = string.Format(CultureInfo.InvariantCulture, ParsingErrorMessage !, DisplayText);
}
return(ret);
}
static bool TryParseDateTimeOffset(string value, out T result)
{
var success = BindConverter.TryConvertToDateTimeOffset(value, CultureInfo.InvariantCulture, DateFormat, out var parsedValue);
if (success)
{
result = (T)(object)parsedValue;
return(true);
}
else
{
result = default;
return(false);
}
}
static bool TryParseDateTime(string?value, [MaybeNullWhen(false)] out TValue result)
{
var success = BindConverter.TryConvertToDateTime(value, CultureInfo.InvariantCulture, DateFormat, out var parsedValue);
if (success)
{
result = (TValue)(object)parsedValue;
return(true);
}
else
{
result = default;
return(false);
}
}
/// <inheritdoc />
protected override void BuildRenderTree(RenderTreeBuilder builder)
{
Debug.Assert(Context != null);
builder.OpenElement(0, "input");
builder.AddMultipleAttributes(1, AdditionalAttributes);
builder.AddAttributeIfNotNullOrEmpty(2, "class", AttributeUtilities.CombineClassNames(AdditionalAttributes, Context.FieldClass));
builder.AddAttribute(3, "type", "radio");
builder.AddAttribute(4, "name", Context.GroupName);
builder.AddAttribute(5, "value", BindConverter.FormatValue(Value?.ToString()));
builder.AddAttribute(6, "checked", Context.CurrentValue?.Equals(Value));
builder.AddAttribute(7, "onchange", Context.ChangeEventCallback);
builder.AddElementReferenceCapture(8, __inputReference => Element = __inputReference);
builder.CloseElement();
}
public override void BuildInputRendererTree(IRendererTreeBuilder rendererTreeBuilder, IActualItemContext <object> actualItemContext, Action <string, object> onChangeAction, string columnName)
{
var value = actualItemContext.GetActualItemColumnValue(columnName);
rendererTreeBuilder
.OpenElement(HtmlTagNames.Div, "edit-field-wrapper")
.OpenElement(HtmlTagNames.Input, "edit-text-field")
.AddAttribute(HtmlAttributes.Type, GetInputType(value?.ToString() ?? InputTypeText))
.AddAttribute(HtmlAttributes.Value, BindConverter.FormatValue(value))
.AddAttribute(HtmlJsEvents.OnChange, EventCallback.Factory.Create(this,
(ChangeEventArgs e) => onChangeAction?.Invoke(columnName, BindConverterExtensions.ConvertTo(e.Value, string.Empty)))
)
.CloseElement()
.CloseElement();
}
/// <inheritdoc />
protected override void BuildRenderTree(RenderTreeBuilder builder)
{
builder.OpenElement(0, "input");
builder.AddMultipleAttributes(1, AdditionalAttributes);
builder.AddAttribute(2, "id", Id);
builder.AddAttribute(3, "required", Required);
builder.AddAttribute(4, "disabled", !Enabled);
builder.AddAttribute(5, "type", "date");
builder.AddAttribute(6, "class", $"{CssClass} pf-c-form-control {(IsValid == true && !HasValidationMessages ? CssClassConstants.Success : String.Empty)} {AdditionalCssClass}");
builder.AddAttribute(7, "value", BindConverter.FormatValue(CurrentValueAsString));
builder.AddAttribute(8, "onchange", EventCallback.Factory.CreateBinder <string>(this, __value => _editingValue = __value, CurrentValueAsString));
builder.AddAttribute(9, "aria-invalid", HasValidationMessages.ToString().ToLower());
builder.AddAttribute(10, "aria-describedby", $"{Id}-helper");
builder.AddAttribute(11, "onblur", EventCallback.Factory.Create <FocusEventArgs>(this, OnBlur));
builder.CloseElement();
}
private static bool ToDateTimeOffset(string value, out T result)
{
var formatString = GetDateTimeFormatString(value);
var success = BindConverter.TryConvertToDateTimeOffset(value, CultureInfo.InvariantCulture, formatString, out DateTimeOffset parsedValue);
if (success)
{
result = (T)(object)parsedValue;
return(true);
}
else
{
result = default;
return(false);
}
}
/// <summary>
/// コンポーネントのレンダリングを行います。
/// </summary>
/// <param name="builder">ビルダ。</param>
protected override void BuildRenderTree(RenderTreeBuilder builder)
{
builder.OpenElement(0, "input");
builder.AddMultipleAttributes(1, this.AdditionalAttributes);
builder.AddAttribute(2, "type", "text");
builder.AddAttribute(3, "value", BindConverter.FormatValue(this.FilterText));
builder.AddAttribute(4, "onchange", EventCallback.Factory.CreateBinder <string>(
this,
__value =>
{
this.FilterText = __value;
this.Filter.FilterOn();
},
this.FilterText
));
builder.CloseElement();
}
protected override bool TryParseValueFromString(string?value, out TEnum result, out string validationErrorMessage)
{
// Let's Blazor convert the value for us 😊
if (BindConverter.TryConvertTo(value, CultureInfo.CurrentCulture, out TEnum? parsedValue))
{
result = parsedValue !;
validationErrorMessage = null !;
return(true);
}
// Map null/empty value to null if the bound object is nullable
if (string.IsNullOrEmpty(value))
{
var nullableType = Nullable.GetUnderlyingType(typeof(TEnum));
if (nullableType is not null)
{
result = default !;
private async System.Threading.Tasks.Task InternalValueChanged(object value)
{
TValue newValue;
try
{
BindConverter.TryConvertTo <TValue>(RemoveNonNumericCharacters(value), Culture, out newValue);
}
catch
{
newValue = default(TValue);
}
decimal?newValueAsDecimal = newValue == null ? default(decimal?) : (decimal)ConvertType.ChangeType(newValue, typeof(decimal));
if (object.Equals(Value, newValue) && !ValueChanged.HasDelegate)
{
await JSRuntime.InvokeAsync <string>("Radzen.setInputValue", input, Value);
return;
}
if (Max.HasValue && newValueAsDecimal > Max.Value)
{
newValueAsDecimal = Max.Value;
}
if (Min.HasValue && newValueAsDecimal < Min.Value)
{
newValueAsDecimal = Min.Value;
}
Value = (TValue)ConvertType.ChangeType(newValueAsDecimal, typeof(TValue));
if (!ValueChanged.HasDelegate)
{
await JSRuntime.InvokeAsync <string>("Radzen.setInputValue", input, Value);
}
await ValueChanged.InvokeAsync(Value);
if (FieldIdentifier.FieldName != null)
{
EditContext?.NotifyFieldChanged(FieldIdentifier);
}
await Change.InvokeAsync(Value);
}
/// <inheritdoc/>
protected override bool TryParseValueFromString(string value, out T result, out string validationErrorMessage)
{
var success = BindConverter.TryConvertTo <T>(value, CultureInfo.CurrentCulture, out var parsedValue);
if (success)
{
result = parsedValue;
validationErrorMessage = null;
return(true);
}
else
{
result = default;
validationErrorMessage = $"{this.FieldIdentifier.FieldName} field isn't valid.";
return(false);
}
}
public void FormatValue_TypeConverter()
{
// Arrange
var value = new Person()
{
Name = "Glenn",
Age = 47,
};
var expected = JsonSerializer.Serialize(value);
// Act
var actual = BindConverter.FormatValue(value);
// Assert
Assert.Equal(expected, actual);
}
/// <inheritdoc />
protected override bool TryParseValueFromString(string?value, [MaybeNullWhen(false)] out TValue result, [NotNullWhen(false)] out string?validationErrorMessage)
{
if (!typeof(TValue).IsEnum)
{
throw new InvalidOperationException($"{this.GetType()} does not support the type '{typeof(TValue)}'.");
}
if (BindConverter.TryConvertTo <TValue>(value, CultureInfo.CurrentCulture, out var parsedValue))
{
result = parsedValue;
validationErrorMessage = null;
return(true);
}
result = default;
validationErrorMessage = $"The {this.FieldIdentifier.FieldName} field is not valid.";
return(false);
}
protected override bool TryParseValueFromString(string?value, [MaybeNullWhen(false)] out TValue result, [NotNullWhen(false)] out string?validationErrorMessage)
{
if (FieldData !.TextType == InputType.Number)
{
value = new string((value ?? "").Where(q => Char.IsDigit(q) || q == '.' || q == ',').ToArray());
}
if (BindConverter.TryConvertTo <TValue>(value, CultureInfo.InvariantCulture, out result))
{
validationErrorMessage = null;
return(true);
}
else
{
validationErrorMessage = string.Format(CultureInfo.InvariantCulture, $"Could not pass '{value}' into {{0}} of type {typeof(TValue).FullName}.", DisplayName ?? FieldIdentifier.FieldName);
return(false);
}
}
protected void OnInput(ChangeEventArgs args, int index = 0)
{
if (index != 0)
{
throw new ArgumentOutOfRangeException("DatePicker should have only single picker.");
}
if (args == null)
{
return;
}
if (BindConverter.TryConvertTo(args.Value.ToString(), CultureInfo, out TValue changeValue))
{
if (Picker == DatePickerType.Date)
{
if (IsDateStringFullDate(args.Value.ToString()))
{
CurrentValue = changeValue;
}
}
else
{
CurrentValue = changeValue;
}
GetIfNotNull(changeValue, (notNullValue) =>
{
PickerValues[0] = notNullValue;
});
if (OnChange.HasDelegate)
{
OnChange.InvokeAsync(new DateTimeChangedEventArgs
{
Date = Convert.ToDateTime(changeValue, this.CultureInfo),
DateString = GetInputValue(index)
});
}
StateHasChanged();
}
UpdateCurrentValueAsString();
}
/// <summary>
/// コンポーネントのレンダリングを行います。
/// </summary>
/// <param name="builder">ビルダ。</param>
protected override void BuildRenderTree(RenderTreeBuilder builder)
{
if (this.Item.EditMode == EditModeOptions.Edit)
{
if (this.EditableState == EditStateOptions.None ||
(this.Item.EditState & this.EditableState) > 0)
{
builder.OpenElement(0, "select");
builder.AddMultipleAttributes(1, AdditionalAttributes);
builder.AddAttribute(2, "value", BindConverter.FormatValue(this.CurrentValueAsString));
builder.AddAttribute(3, "onchange", EventCallback.Factory.CreateBinder <string>(
this,
__value =>
{
this.CurrentValueAsString = __value;
this.SelectedCallBack?.Invoke(this.GetSelectedDropItem());
},
this.CurrentValueAsString
));
if (this.DropItems != null)
{
var seq = 4;
foreach (var dropItem in this.DropItems)
{
builder.OpenElement(seq++, "option");
builder.AddAttribute(seq++, "value", dropItem.Key);
builder.AddContent(seq++, dropItem.Value);
builder.CloseElement();
}
}
builder.CloseElement();
}
else
{
builder.AddContent(100, this.DisplayValue);
}
}
else
{
builder.AddContent(200, this.DisplayValue);
}
base.BuildRenderTree(builder);
}
protected void OnInput(ChangeEventArgs args, int index = 0)
{
if (args == null)
{
return;
}
var array = Value as Array;
if (BindConverter.TryConvertTo(args.Value.ToString(), CultureInfo, out DateTime changeValue))
{
array.SetValue(changeValue, index);
PickerValues[index] = changeValue;
StateHasChanged();
}
UpdateCurrentValueAsString();
}
/// <inheritdoc />
protected override bool TryParseValueFromString(string value, out TValue result, out string validationErrorMessage)
{
if (string.IsNullOrEmpty(value) || value == EmptyValue)
{
validationErrorMessage = string.Format(EmptyErrorMessage, Label);
result = default;
return(false);
}
else if (typeof(TValue) == typeof(string))
{
result = (TValue)(object)value;
validationErrorMessage = null;
return(true);
}
else if (typeof(TValue).IsEnum)
{
var success = BindConverter.TryConvertTo <TValue>(value, CultureInfo.CurrentCulture, out var parsedValue);
if (success)
{
result = parsedValue;
validationErrorMessage = null;
return(true);
}
else
{
result = default;
validationErrorMessage = $"The {FieldIdentifier.FieldName} field is not valid.";
return(false);
}
}
else if (BindConverter.TryConvertTo(value, CultureInfo.InvariantCulture, out result))
{
validationErrorMessage = null;
return(true);
}
else
{
validationErrorMessage = string.Format(ParsingErrorMessage, FieldIdentifier.FieldName);
return(false);
}
throw new InvalidOperationException($"{GetType()} does not support the type '{typeof(TValue)}'.");
}
/// <summary>
/// Method is called via EventCallBack if the keyboard key is no longer pressed inside the Input element.
/// </summary>
/// <param name="e">Contains the key (combination) which was pressed inside the Input element</param>
/// <param name="index">Refers to picker index - 0 for starting date, 1 for ending date</param>
protected async Task OnKeyUp(KeyboardEventArgs e, int index)
{
if (e == null)
{
throw new ArgumentNullException(nameof(e));
}
var key = e.Key.ToUpperInvariant();
if (key == "ENTER")
{
var input = (index == 0 ? _inputStart : _inputEnd);
if (string.IsNullOrWhiteSpace(input.Value))
{
ClearValue(index);
}
else
{
if (BindConverter.TryConvertTo(input.Value, CultureInfo, out DateTime changeValue))
{
var array = Value as Array;
array.SetValue(changeValue, index);
}
if (index == 0)
{
await Blur(0);
await Focus(1);
}
else
{
Close();
}
}
}
if (key == "ARROWDOWN" && !_dropDown.IsOverlayShow())
{
await _dropDown.Show();
}
if (key == "ARROWUP" && _dropDown.IsOverlayShow())
{
Close();
}
}
/// <summary>
/// Renders the component to the supplied RenderTreeBuilder.
/// </summary>
/// <param name="builder">A RenderTreeBuilder that will receive the render output.</param>
protected override void BuildRenderTree(RenderTreeBuilder builder)
{
builder.OpenElement(0, "input");
builder.AddMultipleAttributes(1, AdditionalAttributes);
builder.AddAttribute(2, "type", "text");
builder.AddAttribute(3, "class", CssClass);
builder.AddAttribute(4, "value", BindConverter.FormatValue(CurrentValueAsString));
builder.AddAttribute(5, "onchange", EventCallback.Factory.CreateBinder <String>(this, __value => CurrentValueAsString = __value, CurrentValueAsString));
if (this.BrowserInputMode == BrowserInputMode.Decimal)
{
builder.AddAttribute(6, "inputmode", "decimal");
}
else if (this.BrowserInputMode == BrowserInputMode.Numeric)
{
builder.AddAttribute(6, "inputmode", "numeric");
}
builder.CloseElement();
}
/// <inheritdoc />
protected override bool TryParseValueFromString(string value, out TValue result, out string validationErrorMessage)
{
if (string.IsNullOrEmpty(value))
{
validationErrorMessage = null;
result = default;
return(true);
}
else if (BindConverter.TryConvertTo(value, CultureInfo.InvariantCulture, out result))
{
validationErrorMessage = null;
return(true);
}
else
{
validationErrorMessage = string.Format(ParsingErrorMessage, FieldIdentifier.FieldName);
return(false);
}
}
protected override void BuildRenderTree(RenderTreeBuilder builder)
{
builder.OpenElement(0, "select");
builder.AddMultipleAttributes(1, AdditionalAttributes);
builder.AddAttribute(2, "class", CssClass);
builder.AddAttribute(3, "value", BindConverter.FormatValue(CurrentValueAsString));
builder.AddAttribute(4, "onchange", EventCallback.Factory.CreateBinder <string>(this, value => CurrentValueAsString = value, CurrentValueAsString));
if (_database != null)
{
var i = 5;
if (IsOptional)
{
builder.OpenElement(i++, "option");
builder.CloseElement();
}
foreach (var group in _database.Categories.GroupBy(c => c.GroupName).OrderBy(g => g.Key))
{
if (group.Key != null)
{
builder.OpenElement(i++, "optgroup");
builder.AddAttribute(i++, "label", group.Key);
}
foreach (var category in group.OrderBy(c => c.Name))
{
builder.OpenElement(i++, "option");
builder.AddAttribute(i++, "value", category.Id.ToStringInvariant());
builder.AddContent(i++, category.Name);
builder.CloseElement();
}
if (group.Key != null)
{
builder.CloseElement();
}
}
}
builder.CloseElement();
}
protected override bool TryParseValueFromString(string value, out TValue result, out string errorMessage)
{
var success = BindConverter.TryConvertTo <TValue>(
value, CultureInfo.CurrentCulture, out var parsedValue);
if (success)
{
result = parsedValue;
errorMessage = null;
return(true);
}
else
{
result = default;
errorMessage = $"Invalid data.";
return(false);
}
}
/// <inheritdoc />
protected override bool TryParseValueFromString(string value, out TValue result, out string validationErrorMessage)
{
var targetType = Nullable.GetUnderlyingType(typeof(TValue)) ?? typeof(TValue);
if (typeof(TValue) == typeof(string))
{
result = (TValue)(object)value;
validationErrorMessage = null;
return(true);
}
else if (targetType == typeof(Guid))
{
result = (TValue)(object)Guid.Parse(value);
validationErrorMessage = null;
return(true);
}
else if (targetType == typeof(int))
{
result = (TValue)(object)int.Parse(value);
validationErrorMessage = null;
return(true);
}
else if (typeof(TValue).IsEnum)
{
var success = BindConverter.TryConvertTo <TValue>(value, CultureInfo.CurrentCulture, out var parsedValue);
if (success)
{
result = parsedValue;
validationErrorMessage = null;
return(true);
}
else
{
result = default;
validationErrorMessage = $"The {FieldIdentifier.FieldName} field is not valid.";
return(false);
}
}
throw new InvalidOperationException($"{GetType()} does not support the type '{typeof(TValue)}'.");
}
/// <inheritdoc />
protected override bool TryParseValueFromString(string value, out TValue result, out string validationErrorMessage)
{
CultureInfo culture = CultureInfo.CurrentCulture;
string workingValue = value;
// replace . with ,
if ((culture.NumberFormat.NumberDecimalSeparator == ",") && // when decimal separator is ,
(culture.NumberFormat.NumberGroupSeparator != ".")) // and . is NOT used as group separator)
{
workingValue = workingValue.Replace(".", ",");
}
// omezení počtu desetinných míst
// pro komplikace s tím, že máme TValue a s ním se dost těžko pracuje se omezíme na řešení a úpravu vstupních dat před konverzí do cílového typu
if (Decimal.TryParse(value, IsTValueIntegerType ? NumberStyles.Integer : NumberStyles.Float, culture, out decimal parsedValue))
{
workingValue = Math.Round(parsedValue, DecimalsEffective, MidpointRounding.AwayFromZero).ToString(culture);
}
// konverze do cílového typu
if (BindConverter.TryConvertTo <TValue>(workingValue, culture, out result))
{
// pokud došlo jen ke změně bez změny hodnoty (třeba z 5.50 na 5.5), chceme hodnotu převést na korektní formát (5.5 na 5.50).
// Nestačí však StateHasChange, viz komentář v BuildRenderInput.
if (FormatValueAsString(result) != value)
{
forceRenderValue = true;
}
validationErrorMessage = null;
return(true);
}
else
{
validationErrorMessage = GetParsingErrorMessage();
return(false);
}
}
protected void OnInput(ChangeEventArgs args, int index = 0)
{
if (args == null)
{
return;
}
if (BindConverter.TryConvertTo(args.Value.ToString(), CultureInfo, out TValue changeValue))
{
Value[index] = changeValue;
GetIfNotNull(changeValue, (notNullValue) =>
{
_pickerValues[index] = notNullValue;
});
StateHasChanged();
}
UpdateCurrentValueAsString();
}
protected override void BuildRenderTree(RenderTreeBuilder builder)
{
builder.OpenElement(0, "select");
builder.AddMultipleAttributes(1, AdditionalAttributes);
builder.AddAttribute(2, "class", CssClass);
builder.AddAttribute(3, "value", BindConverter.FormatValue(CurrentValueAsString));
builder.AddAttribute(4, "onchange", EventCallback.Factory.CreateBinder <string>(this, value => CurrentValueAsString = value, CurrentValueAsString, null));
var i = 5;
var enumType = GetEnumType();
foreach (TEnum value in Enum.GetValues(enumType))
{
builder.OpenElement(i++, "option");
builder.AddAttribute(i++, "value", value.ToString());
builder.AddContent(i++, GetDisplayName(value));
builder.CloseElement();
}
builder.CloseElement();
}
public override void ChangeValue(DateTime value, int index = 0)
{
if (index != 0)
{
throw new ArgumentOutOfRangeException("DatePicker should have only single picker.");
}
UseDefaultPickerValue[0] = false;
bool result = BindConverter.TryConvertTo <TValue>(
value.ToString(CultureInfo), CultureInfo, out var dateTime);
if (result)
{
CurrentValue = dateTime;
}
_pickerStatus[0]._hadSelectValue = true;
UpdateCurrentValueAsString();
if (IsRange && !IsShowTime && Picker != DatePickerType.Time)
{
if (_pickerStatus[0]._hadSelectValue && _pickerStatus[1]._hadSelectValue)
{
Close();
}
}
else if (!IsShowTime && Picker != DatePickerType.Time)
{
Close();
}
if (OnChange.HasDelegate)
{
OnChange.InvokeAsync(new DateTimeChangedEventArgs
{
Date = value,
DateString = GetInputValue(0)
});
}
}
