private void EditContext_OnFieldChanged(object sender, FieldChangedEventArgs e)
{
_messageStore.Clear(e.FieldIdentifier);
var letter = e.FieldIdentifier.Model as LetterGuess;
var model = CurrentEditContext.Model as GameModel;
letter.Value = model.Letters[letter.LetterIndex].Value; // Override cos letter.Value sometimes from old word for some reason
if (letter == null || string.IsNullOrEmpty(letter.Value))
{
return;
}
//var correctLetter = model.Word.Value.ToCharArray()[letter.LetterIndex].ToString();
var session = _gameSessionService.Get(_httpContextAccessor.HttpContext.User);
if (_letterGuessService.IsCorrectLetter(session, letter)) //(string.Equals(letter.Value, correctLetter, StringComparison.InvariantCultureIgnoreCase))
{
_gameSessionService.RecordCorrectGuess(session);
// Show this letter if it appears multiple times
var letters = model.Word.Value.ToCharArray();
for (int i = 0; i < letters.Length; i++)
{
if (i != letter.LetterIndex && string.Equals(letters[i].ToString(), letter.Value, StringComparison.InvariantCultureIgnoreCase))
{
model.Letters[i].Value = letter.Value;
}
}
// Check if word matches
if (!model.Letters.Any(l => string.IsNullOrEmpty(l.Value)))
{
var guessedWord = string.Join(null, model.Letters.Select(l => l.Value));
if (string.Equals(guessedWord, model.Word.Value, StringComparison.InvariantCultureIgnoreCase))
{
_gameSessionService.WordFound(session);
model.GameState = GameState.WordFound;
}
}
}
else
{
_gameSessionService.RecordWrongGuess(session);
model.WrongGuesses++;
model.Letters[letter.LetterIndex].Value = string.Empty;
if (session.CurrentWordGuesses >= model.GuessesAllowedPerWord)
{
_gameSessionService.GameOver(session, _httpContextAccessor.HttpContext.User);
model.GameState = GameState.GameOver;
}
}
}
private void ValidateField(object sender, FieldChangedEventArgs args)
{
var component = Form.FindComponent(Component);
if (args.FieldIdentifier.FieldName == component?.FieldIdentifier.FieldName)
{
ValidateModel(sender, ValidationRequestedEventArgs.Empty);
}
}
private void HandleFieldChanged(object sender, FieldChangedEventArgs e)
{
FormValid = EditContext.Validate();
if (!string.IsNullOrEmpty(User.Email))
{
User.Email = User.Email.ToLower();
}
StateHasChanged();
}
private void EditContext_OnFieldChange(
object sender,
FieldChangedEventArgs e)
{
//MetadataChanged.InvokeAsync(this.Metadata);
//LastUpdated = DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss");
State.UpdateLastUpdated(this, DateTime.UtcNow);
}
/// <summary>
/// Handle the field changed event, this should invalidate the correct bounds (e.g. when shadow comes or goes more pixels!)
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void HandleFieldChanged(object sender, FieldChangedEventArgs e)
{
LOG.DebugFormat("Field {0} changed", e.Field.FieldType);
if (e.Field.FieldType == FieldType.SHADOW)
{
accountForShadowChange = true;
}
Invalidate();
}
private void CascadedEditContext_OnFieldChanged(object?sender, FieldChangedEventArgs e)
{
var trail = (TrailDto)e.FieldIdentifier.Model;
if (trail.Id == 0)
{
AppState.NewTrailState.SaveTrail(trail);
}
}
protected void ObfuscateContainer_OnFieldChanged(object sender, FieldChangedEventArgs e)
{
if (sender.Equals(this))
{
if (e.Field.FieldType == FieldType.PREPARED_FILTER_OBFUSCATE)
{
ConfigurePreparedFilters();
}
}
}
protected void BitmapContainer_OnFieldChanged(object sender, FieldChangedEventArgs e)
{
if (sender.Equals(this))
{
if (e.Field.FieldType == FieldType.SHADOW)
{
ChangeShadowField();
}
}
}
protected void HighlightContainer_OnFieldChanged(object sender, FieldChangedEventArgs e)
{
if (sender.Equals(this))
{
if (e.Field.FieldType == FieldType.PREPARED_FILTER_HIGHLIGHT)
{
ConfigurePreparedFilters();
}
}
}
private void HandleFieldChanged(object sender, FieldChangedEventArgs e)
{
formInvalid = !EditContext.Validate();
if (e.FieldIdentifier.FieldName == "DateOfVisit")
{
}
StateHasChanged();
}
protected void BitmapContainer_OnFieldChanged(object sender, FieldChangedEventArgs e)
{
if (!sender.Equals(this))
{
return;
}
if (FieldTypes.SHADOW.Equals(e.Field.FieldType))
{
ChangeShadowField();
}
}
private void MEditContext_OnFieldChanged(object sender, FieldChangedEventArgs e)
{
var field = FieldList.OfType <IMPropertyField>().FirstOrDefault(f => f.Property == e.FieldIdentifier.FieldName);
if (field == null)
{
return;
}
ValidateField(field);
mEditContext.NotifyValidationStateChanged();
}
private void OnFieldChanged(object sender, FieldChangedEventArgs e)
{
var ectx = sender as EditContext;
var list = List;
if (!validationStores.TryGetValue(ectx, out ValidationMessageStore vstore) || list == null)
{
return;
}
vstore.Clear(e.FieldIdentifier);
ValidateProperty(ectx, list[e.FieldIdentifier.FieldName]);
}
private void OnFieldTextChanged(Object sender, TextChangedEventArgs e)
{
if (null != FieldChangedEvent)
{
FieldChangedEventArgs args = new FieldChangedEventArgs();
args.FieldIndex = e.FieldIndex;
args.Text = e.Text;
FieldChangedEvent(this, args);
}
OnTextChanged(EventArgs.Empty);
}
protected void OnSelectedFieldChanged <T>(string fieldName, FieldChangedEventArgs args, Action <T, FieldIdentifier> action)
where T : class
{
if (args.FieldIdentifier.FieldName.Equals(fieldName) && EditContext.IsModified(args.FieldIdentifier))
{
T?model = EditContext.Model as T;
if (model is not null)
{
action.Invoke(model, args.FieldIdentifier);
}
}
}
void FieldChanged(object sender, FieldChangedEventArgs args)
{
FieldIdentifier fieldIdentifier = args.FieldIdentifier;
ValidationMessageStore.Clear();
var model = fieldIdentifier.Model as TModel;
if (model != null)
{
IValidationResult result = Validator.Validate(model);
AddValidationResult(fieldIdentifier.Model, result);
}
}
async void FieldChanged(object sender, FieldChangedEventArgs args)
{
FieldIdentifier fieldIdentifier = args.FieldIdentifier;
ValidationMessageStore.Clear(fieldIdentifier);
var propertiesToValidate = new string[] { fieldIdentifier.FieldName };
var fluentValidationContext =
new ValidationContext(
instanceToValidate: fieldIdentifier.Model,
propertyChain: new FluentValidation.Internal.PropertyChain(),
validatorSelector: new FluentValidation.Internal.MemberNameValidatorSelector(propertiesToValidate)
);
ValidationResult result = await Validator.ValidateAsync(fluentValidationContext);
AddValidationResult(fieldIdentifier.Model, result);
}
private void IsInvalidForm(object s, FieldChangedEventArgs e)
{
if (!string.IsNullOrEmpty(RegisterModel.Username) &&
!string.IsNullOrEmpty(RegisterModel.ConfirmPassword) &&
!string.IsNullOrEmpty(RegisterModel.Password) &&
!string.IsNullOrEmpty(RegisterModel.Email))
{
if (editForm?.EditContext.Validate() == true)
{
IsInvalid = false;
return;
}
}
IsInvalid = true;
}
private async void ConditionContextOnFieldChanged(object sender, FieldChangedEventArgs e)
{
ValidateContext(_conditionContext);
if (e.FieldIdentifier.FieldName == nameof(CreateNotificationPipelineConditionPropertiesViewModel.ConditionName))
{
if (_scopes == null &&
_conditionPropertiesModel.Entries.Count(x => x.Type == NotificationCondititonDescription.ConditionsPropertyTypes.DHCPv6ScopeList) > 0)
{
_scopes = (await _service.GetDHCPv6ScopesAsList()).ToList();
}
_conditionPropertiesModel.SetScopes(_scopes);
base.StateHasChanged();
}
}
void TextContainer_FieldChanged(object sender, FieldChangedEventArgs e)
{
if (textBox.Visible)
{
UpdateTextBoxFormat();
textBox.Invalidate();
}
else
{
UpdateFont();
//Invalidate();
}
font.Dispose();
font = null;
fontInvalidated = true;
}
private void OnFieldChanged(object sender, FieldChangedEventArgs e)
{
var scope = Model.Scopes.FirstOrDefault();
if (IsNew && scope != null)
{
if (scope.Scope == null && e.FieldIdentifier.FieldName == "Id")
{
scope.Scope = Model.Id;
}
if (scope.DisplayName == null && e.FieldIdentifier.FieldName == "DisplayName")
{
scope.DisplayName = Model.DisplayName;
}
}
}
/// <summary>
/// Event Handler for Editcontext.OnFieldChanged
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void FieldChanged(object sender, FieldChangedEventArgs e)
{
// Get the PropertyInfo object for the model property
// Uses reflection to get property and value
var prop = e.FieldIdentifier.Model.GetType().GetProperty(e.FieldIdentifier.FieldName);
if (prop != null)
{
// Get the value for the property
var value = prop.GetValue(e.FieldIdentifier.Model);
// Sets the edit value in the EditField
EditFields.SetField(e.FieldIdentifier.FieldName, value);
// Invokes EditStateChanged
this.EditStateChanged.InvokeAsync(EditFields?.IsDirty ?? false);
}
}
private void TriggerContextOnFieldChanged(object sender, FieldChangedEventArgs e)
{
ValidateContext(_conditionContext);
if (e.FieldIdentifier.FieldName == nameof(CreateNotificationPipelineTriggerPropertiesViewModel.TriggerName))
{
if (String.IsNullOrEmpty(_triggerPropertiesModel.TriggerName) == false)
{
var mapperEntry = _pipelineDescriptions.MapperEnries.First(x => x.TriggerName == _triggerPropertiesModel.TriggerName);
PossibleCondtions = _pipelineDescriptions.Conditions.Where(x => mapperEntry.CompactibleConditions.Contains(x.Name)).Select(x => x.Name).ToList();
PossibleActors = _pipelineDescriptions.Actors.Where(x => mapperEntry.CompactibleActors.Contains(x.Name)).Select(x => x.Name).ToList();
}
else
{
PossibleCondtions = Array.Empty <String>();
PossibleActors = Array.Empty <String>();
}
}
}
private void TextContainer_FieldChanged(object sender, FieldChangedEventArgs e)
{
if (_textBox.Visible)
{
_textBox.Invalidate();
}
// Only dispose the font, and re-create it, when a font field has changed.
if (e.Field.FieldType.Name.StartsWith("FONT"))
{
_font.Dispose();
_font = null;
UpdateFormat();
}
UpdateTextBoxFormat();
if (_textBox.Visible)
{
_textBox.Invalidate();
}
}
private void RulesModeOnFieldChanged(object sender, FieldChangedEventArgs args)
{
if (!ValidateMode.IsIn(FormValidateMode.Rules, FormValidateMode.Complex))
{
return;
}
_rulesValidator.ClearError(args.FieldIdentifier);
var formItem = _formItems
.Single(t => t.GetFieldIdentifier().FieldName == args.FieldIdentifier.FieldName);
var result = formItem.ValidateField();
if (result.Length > 0)
{
var errors = new Dictionary <FieldIdentifier, List <string> >();
errors[args.FieldIdentifier] = result.Select(r => r.ErrorMessage).ToList();
_rulesValidator.DisplayErrors(errors);
}
}
private void EditContext_OnFieldChanged(object sender, FieldChangedEventArgs e)
{
HasChanges = MiniMapper.AnyPropertyValuesDifferent(AuthenticatedUser, FormUser);
StateHasChanged();
UserValidator userValidator = new UserValidator();
ValidationResult results = userValidator.Validate(FormUser);
ModelError = "";
HasErrors = !results.IsValid;
if (HasErrors)
{
HasErrors = true;
foreach (var failure in results.Errors)
{
if (string.IsNullOrEmpty(failure.PropertyName))
{
ModelError += $"{failure.ErrorMessage} \n";
}
}
}
//! wenn email geändert wurde ==> per api auf unique überprüfen, derzeit bei Save von API
}
void OnModelChanged(object?sender, FieldChangedEventArgs e)
{
IsFormInvalid = !_editContext?.Validate() ?? true;
StateHasChanged();
}
private void HandleFieldChanged(object sender, FieldChangedEventArgs e)
{
formInvalid = !editContext.Validate();
StateHasChanged();
}
private void EditContext_OnFieldChanged(object sender, FieldChangedEventArgs e)
{
SetIsDisabled();
}
private void HandleFieldChanged(object sender, FieldChangedEventArgs e)
{
FormValid = ClientInfoContext.Validate();
StateHasChanged();
}
