Example #1
0
        /// <inheritdoc/>
        public override async Task SetParametersAsync(ParameterView parameters)
        {
            var timeChanged          = parameters.TryGetValue(nameof(Time), out TValue time) && !Time.IsEqual(time);
            var minChanged           = parameters.TryGetValue(nameof(Min), out TimeSpan? min) && !Min.IsEqual(min);
            var maxChanged           = parameters.TryGetValue(nameof(Max), out TimeSpan? max) && !Max.IsEqual(max);
            var displayFormatChanged = parameters.TryGetValue(nameof(DisplayFormat), out string displayFormat) && DisplayFormat != displayFormat;
            var timeAs24hrChanged    = parameters.TryGetValue(nameof(TimeAs24hr), out bool timeAs24hr) && TimeAs24hr != timeAs24hr;
            var disabledChanged      = parameters.TryGetValue(nameof(Disabled), out bool disabled) && Disabled != disabled;
            var readOnlyChanged      = parameters.TryGetValue(nameof(ReadOnly), out bool readOnly) && ReadOnly != readOnly;

            if (timeChanged)
            {
                var timeString = FormatValueAsString(time);

                await CurrentValueHandler(timeString);

                if (Rendered)
                {
                    ExecuteAfterRender(async() => await JSModule.UpdateValue(ElementRef, ElementId, timeString));
                }
            }

            if (Rendered && (minChanged ||
                             maxChanged ||
                             displayFormatChanged ||
                             timeAs24hrChanged ||
                             disabledChanged ||
                             readOnlyChanged))
            {
                ExecuteAfterRender(async() => await JSModule.UpdateOptions(ElementRef, ElementId, new
                {
                    DisplayFormat = new { Changed = displayFormatChanged, Value = DateTimeFormatConverter.Convert(displayFormat) },
                    TimeAs24hr    = new { Changed = timeAs24hrChanged, Value = timeAs24hr },
                    Min           = new { Changed = minChanged, Value = min?.ToString(Parsers.InternalTimeFormat) },
                    Max           = new { Changed = maxChanged, Value = max?.ToString(Parsers.InternalTimeFormat) },
                    Disabled      = new { Changed = disabledChanged, Value = disabled },
                    ReadOnly      = new { Changed = readOnlyChanged, Value = readOnly },
                }));
            }

            // Let blazor do its thing!
            await base.SetParametersAsync(parameters);

            if (ParentValidation != null)
            {
                if (parameters.TryGetValue <Expression <Func <TValue> > >(nameof(TimeExpression), out var expression))
                {
                    await ParentValidation.InitializeInputExpression(expression);
                }

                if (parameters.TryGetValue <string>(nameof(Pattern), out var pattern))
                {
                    // make sure we get the newest value
                    var value = parameters.TryGetValue <TValue>(nameof(Time), out var inTime)
                        ? inTime
                        : InternalValue;

                    await ParentValidation.InitializeInputPattern(pattern, value);
                }

                await InitializeValidation();
            }
        }
Example #2
0
        /// <inheritdoc/>
        public override async Task SetParametersAsync(ParameterView parameters)
        {
            var dateChanged           = parameters.TryGetValue <TValue>(nameof(Date), out var date) && !Date.Equals(date);
            var minChanged            = parameters.TryGetValue(nameof(Min), out DateTimeOffset? min) && !Min.IsEqual(min);
            var maxChanged            = parameters.TryGetValue(nameof(Max), out DateTimeOffset? max) && !Max.IsEqual(max);
            var firstDayOfWeekChanged = parameters.TryGetValue(nameof(FirstDayOfWeek), out DayOfWeek firstDayOfWeek) && !FirstDayOfWeek.IsEqual(firstDayOfWeek);
            var displayFormatChanged  = parameters.TryGetValue(nameof(DisplayFormat), out string displayFormat) && DisplayFormat != displayFormat;
            var timeAs24hrChanged     = parameters.TryGetValue(nameof(TimeAs24hr), out bool timeAs24hr) && TimeAs24hr != timeAs24hr;
            var disabledChanged       = parameters.TryGetValue(nameof(Disabled), out bool disabled) && Disabled != disabled;
            var readOnlyChanged       = parameters.TryGetValue(nameof(ReadOnly), out bool readOnly) && ReadOnly != readOnly;
            var disabledDatesChanged  = parameters.TryGetValue(nameof(DisabledDates), out IEnumerable <TValue> disabledDates) && !DisabledDates.AreEqual(disabledDates);

            if (dateChanged)
            {
                var dateString = FormatValueAsString(date);

                await CurrentValueHandler(dateString);

                if (Rendered)
                {
                    ExecuteAfterRender(async() => await JSModule.UpdateValue(ElementRef, ElementId, dateString));
                }
            }

            if (Rendered && (minChanged ||
                             maxChanged ||
                             firstDayOfWeekChanged ||
                             displayFormatChanged ||
                             timeAs24hrChanged ||
                             disabledChanged ||
                             readOnlyChanged ||
                             disabledDatesChanged))
            {
                ExecuteAfterRender(async() => await JSModule.UpdateOptions(ElementRef, ElementId, new
                {
                    FirstDayOfWeek = new { Changed = firstDayOfWeekChanged, Value = (int)firstDayOfWeek },
                    DisplayFormat  = new { Changed = displayFormatChanged, Value = DateTimeFormatConverter.Convert(displayFormat) },
                    TimeAs24hr     = new { Changed = timeAs24hrChanged, Value = timeAs24hr },
                    Min            = new { Changed = minChanged, Value = min?.ToString(DateFormat) },
                    Max            = new { Changed = maxChanged, Value = max?.ToString(DateFormat) },
                    Disabled       = new { Changed = disabledChanged, Value = disabled },
                    ReadOnly       = new { Changed = readOnlyChanged, Value = readOnly },
                    DisabledDates  = new { Changed = disabledDatesChanged, Value = disabledDates?.Select(x => FormatValueAsString(x)) },
                }));
            }

            // Let blazor do its thing!
            await base.SetParametersAsync(parameters);

            if (ParentValidation != null)
            {
                if (parameters.TryGetValue <Expression <Func <TValue> > >(nameof(DateExpression), out var expression))
                {
                    await ParentValidation.InitializeInputExpression(expression);
                }

                if (parameters.TryGetValue <string>(nameof(Pattern), out var pattern))
                {
                    // make sure we get the newest value
                    var value = parameters.TryGetValue <TValue>(nameof(Date), out var inDate)
                        ? inDate
                        : InternalValue;

                    await ParentValidation.InitializeInputPattern(pattern, value);
                }

                await InitializeValidation();
            }
        }
Example #3
0
        /// <inheritdoc/>
        public override async Task SetParametersAsync(ParameterView parameters)
        {
            var timeChanged = parameters.TryGetValue(nameof(Time), out TValue time) && !Time.IsEqual(time);
            var minChanged  = parameters.TryGetValue(nameof(Min), out TimeSpan? min) && !Min.IsEqual(min);
            var maxChanged  = parameters.TryGetValue(nameof(Max), out TimeSpan? max) && !Max.IsEqual(max);

            if (timeChanged)
            {
                var timeString = FormatValueAsString(time);

                await CurrentValueHandler(timeString);

                if (Rendered)
                {
                    ExecuteAfterRender(async() => await JSRunner.UpdateTimePickerValue(ElementRef, ElementId, timeString));
                }
            }

            if (Rendered && (minChanged || maxChanged))
            {
                ExecuteAfterRender(async() => await JSRunner.UpdateTimePickerOptions(ElementRef, ElementId, new
                {
                    Min = new { Changed = minChanged, Value = min?.ToString(Parsers.InternalTimeFormat) },
                    Max = new { Changed = maxChanged, Value = max?.ToString(Parsers.InternalTimeFormat) },
                }));
            }

            // Let blazor do its thing!
            await base.SetParametersAsync(parameters);

            if (ParentValidation != null)
            {
                if (parameters.TryGetValue <Expression <Func <TValue> > >(nameof(TimeExpression), out var expression))
                {
                    await ParentValidation.InitializeInputExpression(expression);
                }

                if (parameters.TryGetValue <string>(nameof(Pattern), out var pattern))
                {
                    // make sure we get the newest value
                    var value = parameters.TryGetValue <TValue>(nameof(Time), out var inTime)
                        ? inTime
                        : InternalValue;

                    await ParentValidation.InitializeInputPattern(pattern, value);
                }

                await InitializeValidation();
            }
        }
Example #4
0
        /// <inheritdoc/>
        public override async Task SetParametersAsync(ParameterView parameters)
        {
            if (Rendered)
            {
                var decimalsChanged                    = isIntegerType ? false : parameters.TryGetValue <int>(nameof(Decimals), out var paramDecimals) && !Decimals.IsEqual(paramDecimals);
                var decimalSeparatorChanged            = parameters.TryGetValue <string>(nameof(DecimalSeparator), out var paramDecimalSeparator) && !DecimalSeparator.IsEqual(paramDecimalSeparator);
                var alternativeDecimalSeparatorChanged = parameters.TryGetValue <string>(nameof(AlternativeDecimalSeparator), out var paramAlternativeDecimalSeparator) && !AlternativeDecimalSeparator.IsEqual(paramAlternativeDecimalSeparator);

                var groupSeparatorChanged = parameters.TryGetValue <string>(nameof(GroupSeparator), out var paramGroupSeparator) && !GroupSeparator.IsEqual(paramGroupSeparator);
                var groupSpacingChanged   = parameters.TryGetValue <string>(nameof(GroupSpacing), out var paramGroupSpacing) && !GroupSpacing.IsEqual(paramGroupSpacing);

                var currencySymbolChanged          = parameters.TryGetValue <string>(nameof(CurrencySymbol), out var paramCurrencySymbol) && !CurrencySymbol.IsEqual(paramCurrencySymbol);
                var currencySymbolPlacementChanged = parameters.TryGetValue <CurrencySymbolPlacement>(nameof(CurrencySymbolPlacement), out var paramCurrencySymbolPlacement) && !CurrencySymbolPlacement.IsEqual(paramCurrencySymbolPlacement);

                var roundingMethodChanged = parameters.TryGetValue <NumericRoundingMethod>(nameof(RoundingMethod), out var paramRoundingMethod) && !RoundingMethod.IsEqual(paramRoundingMethod);

                var minChanged = parameters.TryGetValue <TValue>(nameof(Min), out var paramMin) && !Min.IsEqual(paramMin);
                var maxChanged = parameters.TryGetValue <TValue>(nameof(Max), out var paramMax) && !Max.IsEqual(paramMax);
                var minMaxLimitsOverrideChanged = parameters.TryGetValue <NumericMinMaxLimitsOverride>(nameof(MinMaxLimitsOverride), out var paramMinMaxLimitsOverride) && !MinMaxLimitsOverride.IsEqual(paramMinMaxLimitsOverride);

                var selectAllOnFocusChanged = parameters.TryGetValue <bool>(nameof(SelectAllOnFocus), out var paramSelectAllOnFocus) && !SelectAllOnFocus.IsEqual(paramSelectAllOnFocus);

                var allowDecimalPaddingChanged         = parameters.TryGetValue <NumericAllowDecimalPadding>(nameof(AllowDecimalPadding), out var paramAllowDecimalPadding) && !AllowDecimalPadding.IsEqual(paramAllowDecimalPadding);
                var alwaysAllowDecimalSeparatorChanged = parameters.TryGetValue <bool>(nameof(AlwaysAllowDecimalSeparator), out var paramAlwaysAllowDecimalSeparator) && !AlwaysAllowDecimalSeparator.IsEqual(paramAlwaysAllowDecimalSeparator);

                var modifyValueOnWheelChanged = parameters.TryGetValue <bool>(nameof(ModifyValueOnWheel), out var paramModifyValueOnWheel) && !ModifyValueOnWheel.IsEqual(paramModifyValueOnWheel);
                var wheelOnChanged            = parameters.TryGetValue <NumericWheelOn>(nameof(WheelOn), out var paramWheelOn) && !WheelOn.IsEqual(paramWheelOn);

                if (decimalsChanged || decimalSeparatorChanged || alternativeDecimalSeparatorChanged ||
                    groupSeparatorChanged || groupSpacingChanged ||
                    currencySymbolChanged || currencySymbolPlacementChanged ||
                    roundingMethodChanged ||
                    minChanged || maxChanged ||
                    selectAllOnFocusChanged ||
                    allowDecimalPaddingChanged || alwaysAllowDecimalSeparatorChanged ||
                    modifyValueOnWheelChanged)
                {
                    ExecuteAfterRender(async() => await JSModule.UpdateOptions(ElementRef, ElementId, new
                    {
                        Decimals                    = new { Changed = decimalsChanged, Value = GetDecimals() },
                        DecimalSeparator            = new { Changed = decimalSeparatorChanged, Value = paramDecimalSeparator },
                        AlternativeDecimalSeparator = new { Changed = alternativeDecimalSeparatorChanged, Value = paramAlternativeDecimalSeparator },
                        GroupSeparator              = new { Changed = groupSeparatorChanged, Value = paramGroupSeparator },
                        GroupSpacing                = new { Changed = groupSpacingChanged, Value = paramGroupSpacing },
                        CurrencySymbol              = new { Changed = currencySymbolChanged, Value = paramCurrencySymbol },
                        CurrencySymbolPlacement     = new { Changed = currencySymbolPlacementChanged, Value = paramCurrencySymbolPlacement.ToCurrencySymbolPlacement() },
                        RoundingMethod              = new { Changed = roundingMethodChanged, Value = paramRoundingMethod.ToNumericRoundingMethod() },
                        AllowDecimalPadding         = new { Changed = allowDecimalPaddingChanged, Value = paramAllowDecimalPadding.ToNumericDecimalPadding() },
                        AlwaysAllowDecimalSeparator = new { Changed = alwaysAllowDecimalSeparatorChanged, Value = paramAlwaysAllowDecimalSeparator },
                        Min = new { Changed = minChanged, Value = paramMin },
                        Max = new { Changed = maxChanged, Value = paramMax },
                        MinMaxLimitsOverride = new { Changed = minMaxLimitsOverrideChanged, Value = paramMinMaxLimitsOverride },
                        SelectAllOnFocus     = new { Changed = selectAllOnFocusChanged, Value = paramSelectAllOnFocus },
                        ModifyValueOnWheel   = new { Changed = modifyValueOnWheelChanged, Value = paramModifyValueOnWheel },
                        WheelOn = new { Changed = wheelOnChanged, Value = paramWheelOn },
                    }));
                }

                var valueChanged = parameters.TryGetValue <TValue>(nameof(Value), out var paramValue) && !Value.IsEqual(paramValue);

                if (valueChanged)
                {
                    ExecuteAfterRender(async() => await JSModule.UpdateValue(ElementRef, ElementId, paramValue));
                }
            }

            // This make sure we know that Min or Max parameters are defined and can be checked against the current value.
            // Without we cannot determine if Min or Max has a default value when TValue is non-nullable type.
            MinDefined = parameters.TryGetValue <TValue>(nameof(Min), out var min);
            MaxDefined = parameters.TryGetValue <TValue>(nameof(Max), out var max);

            await base.SetParametersAsync(parameters);

            if (ParentValidation != null)
            {
                if (parameters.TryGetValue <Expression <Func <TValue> > >(nameof(ValueExpression), out var expression))
                {
                    await ParentValidation.InitializeInputExpression(expression);
                }

                if (parameters.TryGetValue <string>(nameof(Pattern), out var pattern))
                {
                    // make sure we get the newest value
                    var value = parameters.TryGetValue <TValue>(nameof(Value), out var inValue)
                        ? inValue
                        : InternalValue;

                    await ParentValidation.InitializeInputPattern(pattern, value);
                }

                await InitializeValidation();
            }
        }
Example #5
0
        /// <inheritdoc/>
        public override async Task SetParametersAsync(ParameterView parameters)
        {
            var dateChanged           = parameters.TryGetValue <TValue>(nameof(Date), out var date) && !Date.Equals(date);
            var minChanged            = parameters.TryGetValue(nameof(Min), out DateTimeOffset? min) && !Min.IsEqual(min);
            var maxChanged            = parameters.TryGetValue(nameof(Max), out DateTimeOffset? max) && !Max.IsEqual(max);
            var firstDayOfWeekChanged = parameters.TryGetValue(nameof(FirstDayOfWeek), out DayOfWeek firstDayOfWeek) && !FirstDayOfWeek.IsEqual(firstDayOfWeek);
            var displayFormatChanged  = parameters.TryGetValue(nameof(DisplayFormat), out string displayFormat) && DisplayFormat != displayFormat;

            if (dateChanged)
            {
                var dateString = FormatValueAsString(date);

                await CurrentValueHandler(dateString);

                if (Rendered)
                {
                    ExecuteAfterRender(async() => await JSRunner.UpdateDatePickerValue(ElementRef, ElementId, dateString));
                }
            }

            if (Rendered && (minChanged || maxChanged || firstDayOfWeekChanged || displayFormatChanged))
            {
                ExecuteAfterRender(async() => await JSRunner.UpdateDatePickerOptions(ElementRef, ElementId, new
                {
                    FirstDayOfWeek = new { Changed = firstDayOfWeekChanged, Value = firstDayOfWeek },
                    DisplayFormat  = new { Changed = displayFormatChanged, Value = displayFormat },
                    Min            = new { Changed = minChanged, Value = min?.ToString(DateFormat) },
                    Max            = new { Changed = maxChanged, Value = max?.ToString(DateFormat) },
                }));
            }

            // Let blazor do its thing!
            await base.SetParametersAsync(parameters);

            if (ParentValidation != null)
            {
                if (parameters.TryGetValue <Expression <Func <TValue> > >(nameof(DateExpression), out var expression))
                {
                    await ParentValidation.InitializeInputExpression(expression);
                }

                if (parameters.TryGetValue <string>(nameof(Pattern), out var pattern))
                {
                    // make sure we get the newest value
                    var value = parameters.TryGetValue <TValue>(nameof(Date), out var inDate)
                        ? inDate
                        : InternalValue;

                    await ParentValidation.InitializeInputPattern(pattern, value);
                }

                await InitializeValidation();
            }
        }
Example #6
0
        /// <inheritdoc/>
        public override async Task SetParametersAsync(ParameterView parameters)
        {
            var dateChanged           = parameters.TryGetValue <TValue>(nameof(Date), out var paramDate) && !Date.Equals(paramDate);
            var datesChanged          = parameters.TryGetValue(nameof(Dates), out IEnumerable <TValue> paramDates) && !Dates.AreEqual(paramDates);
            var minChanged            = parameters.TryGetValue(nameof(Min), out DateTimeOffset? paramMin) && !Min.IsEqual(paramMin);
            var maxChanged            = parameters.TryGetValue(nameof(Max), out DateTimeOffset? paramMax) && !Max.IsEqual(paramMax);
            var firstDayOfWeekChanged = parameters.TryGetValue(nameof(FirstDayOfWeek), out DayOfWeek paramFirstDayOfWeek) && !FirstDayOfWeek.IsEqual(paramFirstDayOfWeek);
            var displayFormatChanged  = parameters.TryGetValue(nameof(DisplayFormat), out string paramDisplayFormat) && DisplayFormat != paramDisplayFormat;
            var timeAs24hrChanged     = parameters.TryGetValue(nameof(TimeAs24hr), out bool paramTimeAs24hr) && TimeAs24hr != paramTimeAs24hr;
            var disabledChanged       = parameters.TryGetValue(nameof(Disabled), out bool paramDisabled) && Disabled != paramDisabled;
            var readOnlyChanged       = parameters.TryGetValue(nameof(ReadOnly), out bool paramReadOnly) && ReadOnly != paramReadOnly;
            var disabledDatesChanged  = parameters.TryGetValue(nameof(DisabledDates), out IEnumerable <TValue> paramDisabledDates) && !DisabledDates.AreEqual(paramDisabledDates);
            var selectionModeChanged  = parameters.TryGetValue(nameof(SelectionMode), out DateInputSelectionMode paramSelectionMode) && !SelectionMode.IsEqual(paramSelectionMode);
            var inlineChanged         = parameters.TryGetValue(nameof(Inline), out bool paramInline) && Inline != paramInline;

            if (dateChanged || datesChanged)
            {
                var formatedDateString = SelectionMode != DateInputSelectionMode.Single
                    ? FormatValueAsString(paramDates?.ToArray())
                    : FormatValueAsString(new TValue[] { paramDate });

                await CurrentValueHandler(formatedDateString);

                if (Rendered)
                {
                    ExecuteAfterRender(async() => await JSModule.UpdateValue(ElementRef, ElementId, formatedDateString));
                }
            }

            if (Rendered && (minChanged ||
                             maxChanged ||
                             firstDayOfWeekChanged ||
                             displayFormatChanged ||
                             timeAs24hrChanged ||
                             disabledChanged ||
                             readOnlyChanged ||
                             disabledDatesChanged ||
                             selectionModeChanged ||
                             inlineChanged))
            {
                ExecuteAfterRender(async() => await JSModule.UpdateOptions(ElementRef, ElementId, new
                {
                    FirstDayOfWeek = new { Changed = firstDayOfWeekChanged, Value = (int)paramFirstDayOfWeek },
                    DisplayFormat  = new { Changed = displayFormatChanged, Value = DateTimeFormatConverter.Convert(paramDisplayFormat) },
                    TimeAs24hr     = new { Changed = timeAs24hrChanged, Value = paramTimeAs24hr },
                    Min            = new { Changed = minChanged, Value = paramMin?.ToString(DateFormat) },
                    Max            = new { Changed = maxChanged, Value = paramMax?.ToString(DateFormat) },
                    Disabled       = new { Changed = disabledChanged, Value = paramDisabled },
                    ReadOnly       = new { Changed = readOnlyChanged, Value = paramReadOnly },
                    DisabledDates  = new { Changed = disabledDatesChanged, Value = paramDisabledDates?.Select(x => FormatValueAsString(new TValue[] { x })) },
                    SelectionMode  = new { Changed = selectionModeChanged, Value = paramSelectionMode },
                    Inline         = new { Changed = inlineChanged, Value = paramInline },
                }));
            }

            // Let blazor do its thing!
            await base.SetParametersAsync(parameters);

            if (ParentValidation != null)
            {
                if (parameters.TryGetValue <Expression <Func <TValue> > >(nameof(DateExpression), out var expression))
                {
                    await ParentValidation.InitializeInputExpression(expression);
                }

                if (parameters.TryGetValue <string>(nameof(Pattern), out var pattern))
                {
                    // make sure we get the newest value
                    var value = parameters.TryGetValue <TValue>(nameof(Date), out var inDate)
                        ? new TValue[] { inDate }
                        : InternalValue;

                    await ParentValidation.InitializeInputPattern(pattern, value);
                }

                await InitializeValidation();
            }
        }