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(); }