private void EventHandler(object sender, ValidationRequestedEventArgs eventArgs)
{
string name;
if (ControlToValidate.Current.ValueExpression.Body is MemberExpression memberExpression)
{
name = memberExpression.Member.Name;
}
else
{
throw new InvalidOperationException("You should not have seen this message, but now that you do" +
"I want you to open an issue here https://github.com/fritzAndFriends/BlazorWebFormsComponents/issues " +
"with a title 'ValueExpression.Body is not MemberExpression' and a sample code to reproduce this. Thanks!");
}
var fieldIdentifier = CurrentEditContext.Field(name);
_messageStore.Clear(fieldIdentifier);
var value = GetCurrentValueAsString();
if (!Enabled || Validate(value))
{
IsValid = true;
}
else
{
IsValid = false;
// Text is for validator, ErrorMessage is for validation summary
_messageStore.Add(fieldIdentifier, Text + "," + ErrorMessage);
}
CurrentEditContext.NotifyValidationStateChanged();
}
private void OnValidationRequested(object?sender, ValidationRequestedEventArgs e)
{
var validationContext = new ValidationContext(_editContext.Model, _serviceProvider, items: null);
var validationResults = new List <ValidationResult>();
Validator.TryValidateObject(_editContext.Model, validationContext, validationResults, true);
// Transfer results to the ValidationMessageStore
_messages.Clear();
foreach (var validationResult in validationResults)
{
if (validationResult == null)
{
continue;
}
var hasMemberNames = false;
foreach (var memberName in validationResult.MemberNames)
{
hasMemberNames = true;
_messages.Add(_editContext.Field(memberName), validationResult.ErrorMessage !);
}
if (!hasMemberNames)
{
_messages.Add(new FieldIdentifier(_editContext.Model, fieldName: string.Empty), validationResult.ErrorMessage !);
}
}
_editContext.NotifyValidationStateChanged();
}
async void ValidationRequested(object sender, ValidationRequestedEventArgs args)
{
ValidationMessageStore.Clear();
ValidationResult result = await Validator.ValidateAsync(EditContext.Model);
AddValidationResult(EditContext.Model, result);
}
private void OnValidationRequested(object?sender, ValidationRequestedEventArgs e)
{
_validationMessages.Clear();
bool somethingIsSelected = false;
if (_input.UpdateEndorsement)
{
somethingIsSelected = true;
if (_input.Endorsement is null)
{
AddIfNoOtherErrors(nameof(_input.Endorsement), "Please enter a new Endorsement.");
}
}
if (_input.UpdateReceiveSignatureRequired)
{
somethingIsSelected = true;
}
if (_input.UpdateAutoAssociationLimit)
{
somethingIsSelected = true;
if (_input.AutoAssociationLimit is null)
{
AddIfNoOtherErrors(nameof(_input.Endorsement), "Please enter an auto association limit value.");
}
}
if (!string.IsNullOrWhiteSpace(_input.AccountMemo))
{
somethingIsSelected = true;
}
if (!somethingIsSelected)
{
_validationMessages.Add(new FieldIdentifier(_input, string.Empty), "Nothing has been selected to change.");
}
}
private void OnValidationRequested(object?sender, ValidationRequestedEventArgs e)
{
_validationMessages.Clear();
var parts = _input.SerialNumbers?.Split(',') ?? Array.Empty <string>();
if (parts.Length == 0)
{
AddIfNoOtherErrors(nameof(_input.SerialNumbers), "Please enter the a comma seperated list of serial numbers to remove from the treasury.");
}
var serialNumbers = new long[parts.Length];
for (int i = 0; i < parts.Length; i++)
{
if (long.TryParse(parts[i].Trim(), out long serialNumber))
{
serialNumbers[i] = serialNumber;
if (serialNumber < 0)
{
AddIfNoOtherErrors(nameof(_input.SerialNumbers), $"Serial Number at location {i + 1} must be a positive value.");
}
}
else
{
AddIfNoOtherErrors(nameof(_input.SerialNumbers), $"Serial Number {parts[i].Trim()} at location {i + 1} is invalid.");
}
}
}
private void ValidateModel(object sender, ValidationRequestedEventArgs args)
{
var component = Form.FindComponent(Component);
if (component == null)
{
throw new InvalidOperationException($"Cannot find component with Name {Component}");
}
if (component.FieldIdentifier.FieldName != null)
{
IsValid = Validate(component);
messages.Clear(component.FieldIdentifier);
if (!IsValid)
{
messages.Add(component.FieldIdentifier, Text);
}
EditContext?.NotifyValidationStateChanged();
}
FieldIdentifier = component.FieldIdentifier;
}
private void OnValidationRequested(object?sender, ValidationRequestedEventArgs e)
{
_validationMessages.Clear();
if (_input.CryptoTransfers is null && _input.TokenTransfers.Count == 0 && _input.AssetTransfers.Count == 0)
{
_validationMessages.Add(new FieldIdentifier(_input, string.Empty), "Please add a Crypto, Token or Asset Transfer.");
}
}
private void MEditContext_OnValidationRequested(object sender, ValidationRequestedEventArgs e)
{
mValidationMessageStore.Clear();
foreach (var field in FieldList.OfType <IMPropertyField>())
{
ValidateField(field);
}
mEditContext.NotifyValidationStateChanged();
}
protected virtual void OnValidationRequested(object?sender, ValidationRequestedEventArgs args)
{
this.validationMessages?.Clear();
if (string.IsNullOrWhiteSpace(this.model.Name))
{
this.validationMessages?.Add(() => this.model.Name, "A state name is required.");
}
if (!this.model.Update && this.States.Select(state => state.Name).Contains(this.model.Name))
{
this.validationMessages?.Add(() => this.model.Name, "Another state with the same name already exists.");
}
}
private async void ValidationRequested(object sender, ValidationRequestedEventArgs args)
{
MessageStore.Clear();
var validationContext =
new ValidationContext <object>(EditContext.Model);
ValidationResult result =
await Validator.ValidateAsync(validationContext);
AddValidationResult(EditContext.Model, result);
}
private void OnValidationRequested(object sender, ValidationRequestedEventArgs e)
{
_validationMessages.Clear();
bool somethingIsSelected =
_input.UpdateAdministrators ||
_input.UpdateContents;
if (!somethingIsSelected)
{
_validationMessages.Add(new FieldIdentifier(_input, string.Empty), "Nothing has been selected to change.");
}
}
void ValidationRequested(object sender, ValidationRequestedEventArgs args)
{
ValidationMessageStore.Clear();
var model = EditContext.Model as TModel;
if (model != null)
{
IValidationResult result = Validator.Validate(model);
AddValidationResult(EditContext.Model, result);
}
}
async void ValidationRequested(object sender, ValidationRequestedEventArgs args)
{
System.Diagnostics.Debug.WriteLine("OnValidationRequested triggered: Validating whole object");
// Clear all errors from a previous validation
_validationMessageStore.Clear();
// Tell FluentValidation to validate the object
ValidationResult result = await _validator.ValidateAsync(EditContext.Model);
// Now add the results to the ValidationMessageStore we created
AddValidationResult(EditContext.Model, result);
}
private void _editContext_OnValidationRequested(object sender, ValidationRequestedEventArgs e)
{
_errorMessage = string.Empty;
if (_editContext != null && For != null)
{
var fieldIdentifier = new FieldIdentifier(_editContext.Model, ((MemberExpression)For.Body).Member.Name);
var message = _editContext.GetValidationMessages(fieldIdentifier);
if (message != null && message.Any())
{
_errorMessage = message.First();
}
}
}
private void OnValidationRequested(object sender, ValidationRequestedEventArgs e)
{
var ectx = sender as EditContext;
var list = List;
if (!validationStores.TryGetValue(ectx, out ValidationMessageStore vstore) || list == null)
{
return;
}
vstore.Clear();
foreach (DataProperty p in list.Properties)
{
ValidateProperty(ectx, p);
}
}
private void OnValidationRequested(object sender, ValidationRequestedEventArgs e)
{
_validationMessages.Clear();
if (_input.MessageIsHex)
{
try
{
Hex.ToBytes(_input.Message);
}
catch (ArgumentException)
{
AddIfNoOtherErrors(nameof(_input.Message), "Unable to parse message as hex.");
}
}
}
private void OnValidationRequested(object?sender, ValidationRequestedEventArgs e)
{
_validationMessages.Clear();
bool somethingIsSelected =
_input.UpdateAdministrator ||
_input.UpdateGrantKycEndorsement ||
_input.UpdateSuspendEndorsement ||
_input.UpdatePauseEndorsement ||
_input.UpdateConfiscateEndorsement ||
_input.UpdateSupplyEndorsement ||
_input.UpdateRoyaltiesEndorsement ||
_input.UpdateRenewAccount ||
_input.UpdateMemo;
if (_input.UpdateSymbol)
{
somethingIsSelected = true;
if (string.IsNullOrWhiteSpace(_input.Symbol))
{
AddIfNoOtherErrors(nameof(_input.Symbol), "Please enter a new symbol value.");
}
else if (!_input.Symbol.All(c => c >= 'A' && c <= 'Z'))
{
AddIfNoOtherErrors(nameof(_input.Symbol), "The symbol can only be upper case characters A-Z.");
}
}
if (_input.UpdateName)
{
somethingIsSelected = true;
if (string.IsNullOrWhiteSpace(_input.Name))
{
AddIfNoOtherErrors(nameof(_input.Name), "Please enter a new name.");
}
}
if (_input.UpdateTreasury)
{
somethingIsSelected = true;
if (_input.Treasury == null || _input.Treasury == Address.None)
{
AddIfNoOtherErrors(nameof(_input.Treasury), "Please enter a valid treasury account.");
}
}
if (!somethingIsSelected)
{
_validationMessages.Add(new FieldIdentifier(_input, string.Empty), "Nothing has been selected to change.");
}
}
private void ValidateRequested(object?editContext, ValidationRequestedEventArgs validationEventArgs)
{
messageStore.Clear();
var tmp = (TRow)Context.Data;
var validationResult = Validator.Validate(tmp);
if (!validationResult.IsValid)
{
foreach (var item in validationResult.Errors)
{
messageStore.Add(new FieldIdentifier(tmp, item.PropertyName), item.ErrorMessage);
}
}
CurrentEditContext.NotifyValidationStateChanged();
}
private void OnValidationRequested(object sender, ValidationRequestedEventArgs e)
{
_validationMessages.Clear();
bool somethingIsSelected =
_input.UpdateAdministrator ||
_input.UpdateParticipant ||
_input.UpdateRenewAccount;
if (_input.UpdateDescription)
{
somethingIsSelected = true;
if (string.IsNullOrWhiteSpace(_input.Description))
{
AddIfNoOtherErrors(nameof(_input.Description), "Please enter a new description.");
}
}
if (!somethingIsSelected)
{
_validationMessages.Add(new FieldIdentifier(_input, string.Empty), "Nothing has been selected to change.");
}
}
private void OnValidationRequested(object sender, ValidationRequestedEventArgs e)
{
_validationMessages.Clear();
bool somethingIsSelected = false;
if (_input.UpdateEndorsement)
{
somethingIsSelected = true;
if (_input.Endorsement == null)
{
AddIfNoOtherErrors(nameof(_input.Endorsement), "Please enter a a new Endorsement.");
}
}
if (_input.UpdateReceiveSignatureRequired)
{
somethingIsSelected = true;
}
if (!somethingIsSelected)
{
_validationMessages.Add(new FieldIdentifier(_input, string.Empty), "Nothing has been selected to change.");
}
}
private void RulesModeOnValidationRequested(object sender, ValidationRequestedEventArgs args)
{
if (!ValidateMode.IsIn(FormValidateMode.Rules, FormValidateMode.Complex))
{
return;
}
_rulesValidator.ClearErrors();
var errors = new Dictionary <FieldIdentifier, List <string> >();
foreach (var formItem in _formItems)
{
var result = formItem.ValidateField();
if (result.Length > 0)
{
errors[formItem.GetFieldIdentifier()] = result.Select(r => r.ErrorMessage).ToList();
}
}
_rulesValidator.DisplayErrors(errors);
}
private void _editContext_OnValidationRequested(object sender, ValidationRequestedEventArgs e)
{
_errorMessage = string.Empty;
if (_editContext != null && For != null && IsErrorFunc == null)
{
var fieldIdentifier = new FieldIdentifier(_editContext.Model, ((MemberExpression)For.Body).Member.Name);
var message = _editContext.GetValidationMessages(fieldIdentifier);
if (message != null && message.Any())
{
_errorMessage = message.First();
}
}
else if (_editContext != null && IsErrorFunc != null && For != null)
{
var isError = IsErrorFunc.Invoke();
if (isError)
{
var messageStore = new ValidationMessageStore(_editContext);
_errorMessage = ErrorMsg;
}
}
}
private void OnValidationRequested(object?sender, ValidationRequestedEventArgs e)
{
_validationMessages.Clear();
if (_input.TokenType == TokenType.Fungible)
{
//[Required(ErrorMessage = "Please enter the initial circulation of tokens (in the smallest denomination).")]
if (_input.Circulation is null)
{
AddIfNoOtherErrors(nameof(_input.Circulation), "Please enter the initial circulation of tokens (in the smallest denomination).");
}
//[Range(1, long.MaxValue, ErrorMessage = "The initial circulation must be greater than or equal to zero.")]
else if (_input.Circulation < 0)
{
AddIfNoOtherErrors(nameof(_input.Circulation), "The initial circulation must be greater than or equal to zero.");
}
//[Range(0, long.MaxValue, ErrorMessage = "The number of decimal places must be zero or larger.")]
if (_input.Decimals is null || _input.Decimals < 0)
{
AddIfNoOtherErrors(nameof(_input.Decimals), "The number of decimal places must be zero or larger.");
}
}
}
private void OnValidationRequested(object?sender, ValidationRequestedEventArgs e)
{
UpdateValidationMessages();
}
private void OnValidationRequested(object?sender, ValidationRequestedEventArgs e)
{
DoValidation();
}
private void ValidationRequested(object sender, ValidationRequestedEventArgs args)
{
this.Validate();
}
private void CurrentEditContext_ValidationRequested(object sender, ValidationRequestedEventArgs e) => ValidateModel();
private void EditContext_OnValidationRequested(object sender, ValidationRequestedEventArgs e)
{
SetIsDisabled();
}
private void OnValidationRequestedHandler(object sender, ValidationRequestedEventArgs e) => InvokeAsync(() => OnValidationRequested.InvokeAsync(e));
public void OnValidationRequestedHandler(object sender, ValidationRequestedEventArgs e)
{
validationRequested = true;
}
