public void Bind(object model_, string propertyOnModel_, Validators.IValidator validator_, bool colourNegRed_) { System.Windows.Forms.Binding binding; binding = new System.Windows.Forms.Binding("Text", model_, propertyOnModel_, validator_ != null, DataSourceUpdateMode.OnPropertyChanged); if (validator_ != null) { binding.Parse += new ConvertEventHandler(validator_.Parse); binding.Format += new ConvertEventHandler(validator_.Format); if (colourNegRed_ && validator_ is Validators.ISignChanged) { UseAppStyling = false; m_validator = validator_; ForeColor = System.Drawing.Color.Red; ((Validators.ISignChanged)validator_).SignChanged += handleSignChanged; ((Validators.ISignChanged)validator_).FireOnSignChanged(); } } if (DataBindings["Text"] != null) DataBindings.Remove(DataBindings["Text"]); DataBindings.Add(binding); }
private void handleSignChanged(object sender, Validators.SignChangedEventArgs e_) { if (IsDisposed) return; ForeColor = (e_.Sign == Sign.Negative) ? System.Drawing.Color.Red : System.Drawing.Color.Black; }
public void Bind(object model_, string propertyOnModel_, Validators.IValidator validator_, DataSourceUpdateMode mode_=DataSourceUpdateMode.OnPropertyChanged) { var binding = new System.Windows.Forms.Binding("Text", model_, propertyOnModel_, validator_ != null, mode_); if (validator_ != null) { binding.Parse+=new ConvertEventHandler(validator_.Parse); binding.Format+=new ConvertEventHandler(validator_.Format); } if (DataBindings["Text"] != null) DataBindings.Remove(DataBindings["Text"]); DataBindings.Add(binding); }
public void Bind(string propertyOnControl_, object model_, string propertyOnModel_, Validators.IValidator validator_) { System.Windows.Forms.Binding binding; binding = new System.Windows.Forms.Binding(propertyOnControl_, model_, propertyOnModel_, validator_ != null, DataSourceUpdateMode.OnPropertyChanged); if (validator_ != null) { binding.Parse += new ConvertEventHandler(validator_.Parse); binding.Format += new ConvertEventHandler(validator_.Format); } if (DataBindings[propertyOnControl_] != null) DataBindings.Remove(DataBindings[propertyOnControl_]); DataBindings.Add(binding); }
private void PrepareSettingsHandles() { bool DevModeVisible() => Prefs.DevMode; PaidRerollsSetting = Settings.GetHandle("paidRerolls", "setting_paidRerolls_label".Translate(), "setting_paidRerolls_desc".Translate(), true); DeterministicRerollsSetting = Settings.GetHandle("deterministicRerolls", "setting_deterministicRerolls_label".Translate(), "setting_deterministicRerolls_desc".Translate(), true); AntiCheeseSetting = Settings.GetHandle("antiCheese", "setting_antiCheese_label".Translate(), "setting_antiCheese_desc".Translate(), true); AntiCheeseSetting.VisibilityPredicate = DevModeVisible; LogConsumedResourcesSetting = Settings.GetHandle("logConsumption", "setting_logConsumption_label".Translate(), "setting_logConsumption_desc".Translate(), false); LogConsumedResourcesSetting.VisibilityPredicate = DevModeVisible; NoVomitingSetting = Settings.GetHandle("noVomiting", "setting_noVomiting_label".Translate(), "setting_noVomiting_desc".Translate(), false); NoVomitingSetting.VisibilityPredicate = DevModeVisible; LoadingMessagesSetting = Settings.GetHandle("loadingMessages", "setting_loadingMessages_label".Translate(), "setting_loadingMessages_desc".Translate(), true); GeyserArrowsSetting = Settings.GetHandle("geyserArrows", "setting_geyserArrows_label".Translate(), "setting_geyserArrows_desc".Translate(), true); PreviewCavesSetting = Settings.GetHandle("previewCaves", "setting_previewCaves_label".Translate(), "setting_previewCaves_desc".Translate(), true); WidgetSizeSetting = Settings.GetHandle("widgetSize", "setting_widgetSize_label".Translate(), "setting_widgetSize_desc".Translate(), MapRerollUIController.DefaultWidgetSize, Validators.IntRangeValidator(MapRerollUIController.MinWidgetSize, MapRerollUIController.MaxWidgetSize)); WidgetSizeSetting.SpinnerIncrement = 8; MapGeneratorModeSetting = Settings.GetHandle("mapGeneratorMode", "setting_mapGeneratorMode_label".Translate(), "setting_mapGeneratorMode_desc".Translate(), MapGeneratorMode.AccuratePreviews, null, "setting_mapGeneratorMode_"); var changeSize = Settings.GetHandle <bool>("changeMapSize", "setting_changeMapSize_label".Translate(), "setting_changeMapSize_desc".Translate()); changeSize.Unsaved = true; changeSize.CustomDrawer = ChangeSizeCustomDrawer; }
public Validation(Validators op, string arg, string error) { this.Operation = op; this.Arg = arg; this.ErrorMessage = error; }
/// <summary> /// Constructor. /// </summary> /// <param name="validators">The validators collection to use.</param> /// <param name="testConfigLimits">The test configuration limits to modify.</param> public Visitor(Validators validators, TestConfigurationLimits testConfigLimits) { this.validators = validators; this.testConfigLimits = testConfigLimits; }
/// <summary> /// Copy constructor. /// </summary> /// <param name="other">The validators collection to clone.</param> public Validators(Validators other) : this() { foreach (var m in other.map) { this.map.Add(m.Key, new List<ConfigurationValidator>(m.Value)); } }
public override void DefsLoaded() { base.DefsLoaded(); Predicate <ThingDef> isMech = (ThingDef d) => d.race != null && d.race.IsMechanoid; Predicate <FactionDef> isHackingFaction = (FactionDef d) => !d.isPlayer && d != FactionDefOf.Mechanoid && d != FactionDefOf.Insect; allMechs = (from td in DefDatabase <ThingDef> .AllDefs where isMech(td) select td).ToList(); allFactionNames = (from td in DefDatabase <FactionDef> .AllDefs where isHackingFaction(td) select td.defName).ToList(); tabsHandler = Settings.GetHandle <String>("tabs", "WTH_FactionRestrictions_Label".Translate(), "WTH_FactionRestrictions_Description".Translate(), allFactionNames.First()); tabsHandler.CustomDrawer = rect => { return(false); }; factionRestrictions = Settings.GetHandle <Dict2DRecordHandler>("factionRestrictions", "", "", null); factionRestrictions.CustomDrawer = rect => { return(GUIDrawUtility.CustomDrawer_MatchingPawns_active(rect, factionRestrictions, allMechs, allFactionNames, tabsHandler, "WTH_FactionRestrictions_OK".Translate(), "WTH_FactionRestrictions_NOK".Translate())); }; hackedMechChance = Settings.GetHandle <int>("hackedMechChance", "WTH_HackedMechChance_Title".Translate(), "WTH_HackedMechChance_Description".Translate(), 60, Validators.IntRangeValidator(0, 100)); maxHackedMechPoints = Settings.GetHandle <int>("maxHackedMechPoints", "WTH_MaxHackedMechPoints_Title".Translate(), "WTH_MaxHackedMechPoints_Description".Translate(), 50, Validators.IntRangeValidator(0, 500)); minHackedMechPoints = Settings.GetHandle <int>("minHackedMechPoints", "WTH_MinHackedMechPoints_Title".Translate(), "WTH_MinHackedMechPoints_Description".Translate(), 0, Validators.IntRangeValidator(0, 500)); failureChanceNothing = Settings.GetHandle <int>("failureChanceNothing", "WTH_FailureChance_Nothing_Title".Translate(), "WTH_FailureChance_Nothing_Description".Translate(), 70); failureChanceCauseRaid = Settings.GetHandle <int>("failureChanceCauseRaid", "WTH_FailureChance_CauseRaid_Title".Translate(), "WTH_FailureChance_CauseRaid_Description".Translate(), 5); failureChanceShootRandomDirection = Settings.GetHandle <int>("failureChanceShootRandomDirection", "WTH_FailureChance_ShootRandomDirection_Title".Translate(), "WTH_FailureChance_ShootRandomDirection_Description".Translate(), 10); failureChanceHealToStanding = Settings.GetHandle <int>("failureChanceHealToStanding", "WTH_FailureChance_HealToStanding_Title".Translate(), "WTH_FailureChance_HealToStanding_Description".Translate(), 5); failureChanceHackPoorly = Settings.GetHandle <int>("failureChanceHackPoorly", "WTH_FailureChance_HackPoorly_Title".Translate(), "WTH_FailureChance_HackPoorly_Description".Translate(), 10); maintenanceDecayEnabled = Settings.GetHandle <bool>("maintenanceDecayEnabled", "WTH_MaintenanceDedayEnabled_Title".Translate(), "WTH_MaintenanceDedayEnabled_Description".Translate(), true); factionRestrictions = GetDefaultForFactionRestrictions(factionRestrictions, allMechs, allFactionNames); GenerateImpliedRecipeDefs(); DefDatabase <ThingDef> .ResolveAllReferences(true); SetMechMarketValue(); }
public NegateExpression(Expression value) : base(DetermineResultType(Validators.NullCheck(value, "value"))) { _value = value; }
private static async Task RequestFilterAsync(IRequest req, IResponse res, object requestDto, bool treatInfoAndWarningsAsErrors) { var requestType = requestDto.GetType(); await Validators.AssertTypeValidatorsAsync(req, requestDto, requestType); var validator = ValidatorCache.GetValidator(req, requestType); if (validator == null) { return; } using (validator as IDisposable) { if (validator is IHasTypeValidators hasTypeValidators && hasTypeValidators.TypeValidators.Count > 0) { foreach (var scriptValidator in hasTypeValidators.TypeValidators) { await scriptValidator.ThrowIfNotValidAsync(requestDto, req); } } try { if (req.Verb == HttpMethods.Patch) { // Ignore property rules for AutoCrud Patch operations with default values (which are ignored) if (validator is IServiceStackValidator ssValidator && requestDto is ICrud && requestType.IsOrHasGenericInterfaceTypeOf(typeof(IPatchDb <>))) { var typeProperties = TypeProperties.Get(requestType); var propsWithDefaultValues = new HashSet <string>(); foreach (var entry in typeProperties.PropertyMap) { if (entry.Value.PublicGetter == null) { continue; } var defaultValue = entry.Value.PropertyInfo.PropertyType.GetDefaultValue(); var propValue = entry.Value.PublicGetter(requestDto); if (propValue == null || propValue.Equals(defaultValue)) { propsWithDefaultValues.Add(entry.Key); } } if (propsWithDefaultValues.Count > 0) { ssValidator.RemovePropertyRules(rule => propsWithDefaultValues.Contains(rule.PropertyName)); } } } var validationResult = await validator.ValidateAsync(req, requestDto); if (treatInfoAndWarningsAsErrors && validationResult.IsValid) { return; } if (!treatInfoAndWarningsAsErrors && (validationResult.IsValid || validationResult.Errors.All(v => v.Severity != Severity.Error))) { return; } var errorResponse = await HostContext.RaiseServiceException(req, requestDto, validationResult.ToException()) ?? DtoUtils.CreateErrorResponse(requestDto, validationResult.ToErrorResult()); var autoBatchIndex = req.GetItem(Keywords.AutoBatchIndex)?.ToString(); if (autoBatchIndex != null) { var responseStatus = errorResponse.GetResponseStatus(); if (responseStatus != null) { if (responseStatus.Meta == null) { responseStatus.Meta = new Dictionary <string, string>(); } responseStatus.Meta[Keywords.AutoBatchIndex] = autoBatchIndex; } } var validationFeature = HostContext.GetPlugin <ValidationFeature>(); if (validationFeature?.ErrorResponseFilter != null) { errorResponse = validationFeature.ErrorResponseFilter(req, validationResult, errorResponse); } await res.WriteToResponse(req, errorResponse); } catch (Exception ex) { var validationEx = ex.UnwrapIfSingleException(); var errorResponse = await HostContext.RaiseServiceException(req, requestDto, validationEx) ?? DtoUtils.CreateErrorResponse(requestDto, validationEx); await res.WriteToResponse(req, errorResponse); } } }
public CSPrice GetPrice(long dateTime) { Validators.CheckDateTime(dateTime); int day = DateToDay.ToDay((int)(dateTime / 1000000)); SortedList <CSPrice> prices = GetDayPrices(day); CSPrice[] matched = prices.GetMatchWithEdge(prices.GetFerret(new CSPrice() { DateTime = dateTime })).ToArray(); if (matched.Length == 3) { return(matched[1]); } if (matched.Length != 2) { throw null; // 2bs -- 同じ日時のデータは無いはず! } if (matched[0] == null) { for (int c = 1; c <= Consts.MARGIN_DAY_MAX; c++) { prices = GetDayPrices(day - c); if (1 <= prices.Count) { matched[0] = prices.Get(prices.Count - 1); break; } } } if (matched[1] == null) { for (int c = 1; c <= Consts.MARGIN_DAY_MAX; c++) { prices = GetDayPrices(day + c); if (1 <= prices.Count) { matched[0] = prices.Get(0); break; } } } matched = matched.Where(v => v != null).ToArray(); if (matched.Length == 0) { return new CSPrice() { DateTime = dateTime } } ; if (matched.Length == 1) { return(matched[0]); } long sec1 = DateTimeToSec.ToSec(matched[0].DateTime); long sec2 = DateTimeToSec.ToSec(dateTime); long sec3 = DateTimeToSec.ToSec(matched[1].DateTime); double rate = (sec2 - sec1) * 1.0 / (sec3 - sec1); return(new CSPrice() { DateTime = dateTime, Hig = matched[0].Hig + rate * (matched[1].Hig - matched[0].Hig), Low = matched[0].Low + rate * (matched[1].Low - matched[0].Low), Ask = matched[0].Ask + rate * (matched[1].Ask - matched[0].Ask), Bid = matched[0].Bid + rate * (matched[1].Bid - matched[0].Bid), }); } }
public override void OnBlockProcessingStart(Block block, ProcessingOptions options = ProcessingOptions.None) { if (block.IsGenesis) { return; } var isProducingBlock = options.IsProducingBlock(); var isProcessingBlock = !isProducingBlock; var isInitBlock = InitBlockNumber == block.Number; var notConsecutiveBlock = block.Number - 1 > _lastProcessedBlockNumber || _lastProcessedBlockNumber == 0; var shouldLoadValidators = Validators == null || notConsecutiveBlock || isProducingBlock; var mainChainProcessing = !ForSealing && isProcessingBlock; if (shouldLoadValidators) { Validators = isInitBlock || notConsecutiveBlock ? LoadValidatorsFromContract(BlockTree.FindParentHeader(block.Header, BlockTreeLookupOptions.None)) : ValidatorStore.GetValidators(); if (mainChainProcessing) { if (_logger.IsInfo) { _logger.Info($"{(isInitBlock ? "Initial" : "Current")} contract validators ({Validators.Length}): [{string.Join<Address>(", ", Validators)}]."); } } } if (isInitBlock) { if (mainChainProcessing) { ValidatorStore.SetValidators(InitBlockNumber, Validators); } InitiateChange(block, Validators.ToArray(), isProcessingBlock, true); } else { if (mainChainProcessing && notConsecutiveBlock) { bool loadedValidatorsAreSameInStore = (ValidatorStore.GetValidators()?.SequenceEqual(Validators) == true); if (!loadedValidatorsAreSameInStore) { ValidatorStore.SetValidators(_blockFinalizationManager.GetLastLevelFinalizedBy(block.ParentHash), Validators); } } if (isProcessingBlock) { bool reorganisationHappened = block.Number <= _lastProcessedBlockNumber; if (reorganisationHappened) { var reorganisationToBlockBeforePendingValidatorsInitChange = block.Number <= CurrentPendingValidators?.BlockNumber; SetPendingValidators(reorganisationToBlockBeforePendingValidatorsInitChange ? null : LoadPendingValidators(), reorganisationToBlockBeforePendingValidatorsInitChange); } else if (block.Number > _lastProcessedBlockNumber + 1) // blocks skipped, like fast sync { SetPendingValidators(TryGetInitChangeFromPastBlocks(block.ParentHash), true); } } else { // if we are not processing blocks we are not on consecutive blocks. // We need to initialize pending validators from db on each block being produced. SetPendingValidators(LoadPendingValidators()); } } base.OnBlockProcessingStart(block, options); FinalizePendingValidatorsIfNeeded(block.Header, isProcessingBlock); _lastProcessedBlockNumber = block.Number; }
protected override Validators.Rule InnerConfigure(Validators.Rule rule) { return rule.MaxLength(MaxLenght); }
public Validators.Rule Configure(Type resourceType, Validators.Rule rule) { return rule.Required(null); }
public virtual IValidationCollection AddWebsite() { Validators.Add(new PatternValidator(@"^([a-zA-Z]{3,9}:(\/){2})?([a-zA-Z0-9\.]*){1}(?::[a-zA-Z0-9]{1,4})?(?:\/[_\,\$#~\?\-\+=&;%@\.\w%]+)*(?:\/)?$")); return(this); }
public bool Has <TValidator>() where TValidator : IValidator { return(Validators.Any(d => d is TValidator)); }
public ValidatorPredicate(Validators id, PredicatePriority priority, Func <Rule, string, bool> eval) { _id = id; _evaluator = eval; Priority = priority; }
/// <summary> /// Adds the validator. /// </summary> /// <param name="validator">The validator.</param> public void AddValidator(Validators.IValidator validator) { if (validator != null) { this.validators.Add(validator); } }
public bool IsA(Validators identifier) { return((identifier & _id) == _id); }
/// <summary> /// Empties and refreshes the validator library. Reloads configuration from the xml file. /// </summary> public static void Refresh() { // Clear lists and set to null. _validators.Clear(); _validators = null; _validatorLib = null; }
protected virtual void ValidateLifetime(DateTime?notBefore, DateTime?expires, SecurityToken securityToken, TokenValidationParameters validationParameters) => Validators.ValidateLifetime(notBefore, expires, securityToken, validationParameters);
/// <summary> /// For a given payload element determines its test configuration limits. /// </summary> /// <param name="payloadElement">The payload element to check.</param> /// <param name="validators">The collection of validators to use.</param> /// <returns>The test configuration limits computed.</returns> public static TestConfigurationLimits GetTestConfigurationLimits(ODataPayloadElement payloadElement, Validators validators) { TestConfigurationLimits testConfigLimits = new TestConfigurationLimits(); new Visitor(validators, testConfigLimits).Visit(payloadElement); return testConfigLimits; }
protected virtual void ValidateAudience(IEnumerable <string> audiences, SecurityToken securityToken, TokenValidationParameters validationParameters) => Validators.ValidateAudience(audiences, securityToken, validationParameters);
/// <summary> /// Determines whether the specified identifier is a. /// </summary> /// <param name="identifier">The identifier.</param> /// <returns><c>true</c> if the specified identifier is a; otherwise, <c>false</c>.</returns> public bool IsA(Validators identifier) { return (identifier & _id) == _id; }
protected virtual string ValidateIssuer(string issuer, SecurityToken securityToken, TokenValidationParameters validationParameters) => Validators.ValidateIssuer(issuer, securityToken, validationParameters);
private static void RunPasswordSample() { var secret = Prompt.Password("Type new password", new[] { Validators.Required(), Validators.MinLength(8) }); Console.WriteLine("Password OK"); }
protected virtual void ValidateTokenReplay(DateTime?expirationTime, string securityToken, TokenValidationParameters validationParameters) => Validators.ValidateTokenReplay(expirationTime, securityToken, validationParameters);
// // Main loop. This will be called each 60s and also when the settings are reloaded // private async void LoadGlucoseValue() { if (!Validators.IsUrl(this.nsURL, Default.AllowFileURIScheme)) { this.showErrorMessage("The nightscout_site setting is not specifed or invalid. Please update it from the settings!"); return; } PebbleData data = null; var alarmManger = SoundAlarm.Instance; var now = DateTime.Now; var alarmsPostponed = alarmManger.GetPostponedUntil(); //cleanup context menu if (alarmsPostponed != null && alarmsPostponed < now) { this.postponedUntilFooToolStripMenuItem.Visible = this.reenableAlarmsToolStripMenuItem.Visible = false; } try { WriteDebug("Trying to refresh data"); data = await PebbleData.GetNightscoutPebbleDataAsync(this.nsURL); var glucoseDate = data.LocalDate; this.lblLastUpdate.Text = glucoseDate.ToTimeAgo(); // // even if we have glucose data, don't display them if it's considered stale // if (Default.EnableAlarms) { var urgentTime = now.AddMinutes(-Default.AlarmStaleDataUrgent); var warningTime = now.AddMinutes(-Default.AlarmStaleDataWarning); var isUrgent = glucoseDate <= urgentTime; var isWarning = glucoseDate <= warningTime; if (isUrgent || isWarning) { this.lblGlucoseValue.Text = "Stale"; this.lblDelta.Text = "data"; this.notifyIcon1.Text = "Stale data"; alarmManger.PlayStaleAlarm(); if (isUrgent) { setLabelsColor(Color.Red); } else { setLabelsColor(Color.Yellow); } return; } } string arrow = data.DirectionArrow; //mgdl values are always reported in whole numbers this.lblGlucoseValue.Text = Default.GlucoseUnits == "mmol" ? $"{data.Glucose:N1} {arrow}" : $"{data.Glucose:N0} {arrow}"; this.notifyIcon1.Text = "BG: " + this.lblGlucoseValue.Text; var status = GlucoseStatus.GetGlucoseStatus((decimal)data.Glucose); this.lblDelta.Text = data.FormattedDelta + " " + (Default.GlucoseUnits == "mmol" ? "mmol/L" : "mg/dL"); if (Default.EnableRawGlucoseDisplay) { this.lblRawBG.Text = $"{data.RawGlucose:N1}"; } this.SetSuccessState(); switch (status) { case GlucoseStatusEnum.UrgentHigh: case GlucoseStatusEnum.UrgentLow: setLabelsColor(Color.Red); alarmManger.PlayGlucoseAlarm(); break; case GlucoseStatusEnum.Low: case GlucoseStatusEnum.High: setLabelsColor(Color.Yellow); alarmManger.PlayGlucoseAlarm(); break; case GlucoseStatusEnum.Unknown: case GlucoseStatusEnum.Normal: default: alarmManger.StopAlarm(); setLabelsColor(Color.Green); break; } } catch (FileNotFoundException ex) { //will only happen during debugging, when the allow file:/// scheme is set this.showErrorMessage($"Could not find file '{ex.FileName}'!"); this.SetErrorState(ex); return; } catch (IOException ex) { this.SetErrorState(ex); } catch (HttpRequestException ex) { this.SetErrorState(ex); } catch (JsonReaderException ex) { this.SetErrorState(ex); } catch (MissingDataException ex) { //typically happens during azure site restarts this.SetErrorState(ex); } catch (JsonSerializationException ex) { //typically happens during azure site restarts this.SetErrorState(ex); } catch (InvalidJsonDataException ex) { this.SetErrorState(ex); this.showErrorMessage(ex.Message); AppShared.SettingsFormShouldFocusAdvancedSettings = true; this.settingsForm.Visible = false; this.settingsForm.ShowDialog(); } catch (Exception ex) { var msg = "An unknown error occured of type " + ex.GetType().ToString() + ": " + ex.Message; this.showErrorMessage(msg); Application.Exit(); } try { if (Default.EnableRawGlucoseDisplay && data != null) { this.lblRawDelta.Text = data.FormattedRawDelta; } } catch (InvalidJsonDataException) { // No data available. // This can happen even if raw glucose is enabled // as it required two data points to be available this.lblRawDelta.Text = "-"; } //these are just for layout tests //this.lblGlucoseValue.Text = "+500.0"; //this.lblRawBG.Text = "+489.5"; //this.lblRawDelta.Text = "+50.0"; //this.lblDelta.Text = "-50.0"; }
protected virtual void ValidateIssuerSecurityKey(SecurityKey securityKey, SecurityToken securityToken, TokenValidationParameters validationParameters) => Validators.ValidateIssuerSecurityKey(securityKey, securityToken, validationParameters);
public virtual IValidationCollection AddRequired(string reqCondition = null) { Validators.Add(new RequiredValidator(reqCondition)); return(this); }
/// <summary> /// Ввалидация ввода на цифры /// </summary> internal void Validinput(KeyEventArgs e, object s) { Validators.Validinput(e, s); }
public bool HasRequired() { return(Validators.Any(d => d is RequiredValidator)); }
public override void DefsLoaded() { // No need to do anything if the mod is disabled if (!ModIsActive) { return; } // Basic capacity values pawnMassCapacity = Settings.GetHandle <float>("pawnMassCapacity", "WobCapacityLimits.PawnMassCapacity.Title".Translate(), "WobCapacityLimits.PawnMassCapacity.Desc".Translate(), 35f, Validators.FloatRangeValidator(1, float.MaxValue)); podMassCapacity = Settings.GetHandle <float>("podMassCapacity", "WobCapacityLimits.PodMassCapacity.Title".Translate(), "WobCapacityLimits.PodMassCapacity.Desc".Translate(), 150f, Validators.FloatRangeValidator(1, float.MaxValue)); podFuelPerTile = Settings.GetHandle <float>("podFuelPerTile", "WobCapacityLimits.PodFuelPerTile.Title".Translate(), "WobCapacityLimits.PodFuelPerTile.Desc".Translate(), 2.25f, Validators.FloatRangeValidator(float.Epsilon, float.MaxValue)); // Stack maximum size multipliers mealsStack = Settings.GetHandle <float>("mealsStack", "WobCapacityLimits.Stack.Meals.Title".Translate(), "WobCapacityLimits.Stack.Meals.Desc".Translate(), 1.0f, Validators.FloatRangeValidator(float.Epsilon, float.MaxValue)); foodStack = Settings.GetHandle <float>("foodStack", "WobCapacityLimits.Stack.Food.Title".Translate(), "WobCapacityLimits.Stack.Food.Desc".Translate(), 1.0f, Validators.FloatRangeValidator(float.Epsilon, float.MaxValue)); animalfeedStack = Settings.GetHandle <float>("animalfeedStack", "WobCapacityLimits.Stack.AnimalFeed.Title".Translate(), "WobCapacityLimits.Stack.AnimalFeed.Desc".Translate(), 1.0f, Validators.FloatRangeValidator(float.Epsilon, float.MaxValue)); textilesStack = Settings.GetHandle <float>("textilesStack", "WobCapacityLimits.Stack.Textiles.Title".Translate(), "WobCapacityLimits.Stack.Textiles.Desc".Translate(), 1.0f, Validators.FloatRangeValidator(float.Epsilon, float.MaxValue)); medicineStack = Settings.GetHandle <float>("medicineStack", "WobCapacityLimits.Stack.Medicine.Title".Translate(), "WobCapacityLimits.Stack.Medicine.Desc".Translate(), 1.0f, Validators.FloatRangeValidator(float.Epsilon, float.MaxValue)); drugsStack = Settings.GetHandle <float>("drugsStack", "WobCapacityLimits.Stack.Drugs.Title".Translate(), "WobCapacityLimits.Stack.Drugs.Desc".Translate(), 1.0f, Validators.FloatRangeValidator(float.Epsilon, float.MaxValue)); manufacturedStack = Settings.GetHandle <float>("manufacturedStack", "WobCapacityLimits.Stack.Manufactured.Title".Translate(), "WobCapacityLimits.Stack.Manufactured.Desc".Translate(), 1.0f, Validators.FloatRangeValidator(float.Epsilon, float.MaxValue)); silverStack = Settings.GetHandle <float>("silverStack", "WobCapacityLimits.Stack.Silver.Title".Translate(), "WobCapacityLimits.Stack.Silver.Desc".Translate(), 1.0f, Validators.FloatRangeValidator(float.Epsilon, float.MaxValue)); resourcesStack = Settings.GetHandle <float>("resourcesStack", "WobCapacityLimits.Stack.Resources.Title".Translate(), "WobCapacityLimits.Stack.Resources.Desc".Translate(), 1.0f, Validators.FloatRangeValidator(float.Epsilon, float.MaxValue)); chunksStack = Settings.GetHandle <float>("chunksStack", "WobCapacityLimits.Stack.Chunks.Title".Translate(), "WobCapacityLimits.Stack.Chunks.Desc".Translate(), 1.0f, Validators.FloatRangeValidator(float.Epsilon, float.MaxValue)); artifactsStack = Settings.GetHandle <float>("artifactsStack", "WobCapacityLimits.Stack.Artifacts.Title".Translate(), "WobCapacityLimits.Stack.Artifacts.Desc".Translate(), 1.0f, Validators.FloatRangeValidator(float.Epsilon, float.MaxValue)); bodypartsStack = Settings.GetHandle <float>("bodypartsStack", "WobCapacityLimits.Stack.BodyParts.Title".Translate(), "WobCapacityLimits.Stack.BodyParts.Desc".Translate(), 1.0f, Validators.FloatRangeValidator(float.Epsilon, float.MaxValue)); miscStack = Settings.GetHandle <float>("miscStack", "WobCapacityLimits.Stack.Misc.Title".Translate(), "WobCapacityLimits.Stack.Misc.Desc".Translate(), 1.0f, Validators.FloatRangeValidator(float.Epsilon, float.MaxValue)); // Verbose logging for debugging debugMode = Settings.GetHandle <bool>("debugMode", "WobCapacityLimits.DebugMode.Title".Translate(), "WobCapacityLimits.DebugMode.Desc".Translate(), false); stackSizes = new Dictionary <string, int>(); // Set static values used in harmony patches SettingsContainer.pawnMassCapacityValue = pawnMassCapacity.Value; SettingsContainer.podFuelPerTileValue = podFuelPerTile.Value; // Edit the pod capacity property EditPodMassCapacity(podMassCapacity.Value); // Modify stack sizes, and return the maximum stack size int maxStack = EditStackLimits(true); // Edit the pawn carry capacity to the maximum stack size EditPawnStackCapacity(maxStack); // All initialised, note on log Logger.Message("Loaded"); }
public void Bind(object model_, string propertyOnModel_, Validators.IValidator validator_) { Bind(model_, propertyOnModel_, validator_, false); }
/// <summary> /// internal construct subscriber object /// </summary> /// <param name="logger">ILogger instance</param> /// <param name="hostConfig">rabbitMQ configuration</param> public RabbitMQSubscriberWorker( IServiceProvider serviceProvider, ILoggerFactory logger, RabbitMQConfiguration hostConfig, Action <Func <byte[]> > callback) : base(serviceProvider) { _logger = logger? .AddConsole() .AddDebug() .CreateLogger <RabbitMQPublisher>() ?? throw new ArgumentNullException("Logger reference is required"); try { Validators.EnsureHostConfig(hostConfig); _hostConfig = hostConfig; exchange = _hostConfig.exchange; route = _hostConfig.routes.FirstOrDefault() ?? throw new ArgumentNullException("route queue is missing."); this.callback = callback ?? throw new ArgumentNullException("Callback reference is invalid"); var host = Helper.ExtractHostStructure(_hostConfig.hostName); connectionFactory = new ConnectionFactory() { HostName = host.hostName, Port = host.port ?? defaultMiddlewarePort, UserName = _hostConfig.userName, Password = _hostConfig.password, ContinuationTimeout = TimeSpan.FromSeconds(DomainModels.System.Identifiers.TimeoutInSec) }; new Function(_logger, DomainModels.System.Identifiers.RetryCount).Decorate(() => { connection = connectionFactory.CreateConnection(); channel = connection.CreateModel(); channel.ExchangeDeclare(exchange: exchange, type: ExchangeType.Topic, durable: true); channel.ExchangeDeclare(exchange: _hostConfig.exchange, type: ExchangeType.Topic, durable: true); //TODO: in case scaling the middleware, running multiple workers simultaneously. channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false); return(Task.CompletedTask); }, (ex) => { switch (ex) { case BrokerUnreachableException brokerEx: return(true); case ConnectFailureException connEx: return(true); case SocketException socketEx: return(true); default: return(false); } }).Wait(); queueName = channel.QueueDeclare().QueueName; foreach (var bindingKey in _hostConfig.routes) { channel.QueueBind(queue: queueName, exchange: _hostConfig.exchange, routingKey: bindingKey); } consumer = new EventingBasicConsumer(channel); consumer.Received += async(model, ea) => { await new Function(_logger, DomainModels.System.Identifiers.RetryCount).Decorate(() => { if (ea.Body == null || ea.Body.Length == 0) { throw new TypeLoadException("Invalid message type"); } // callback action feeding callback(() => ea.Body); channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false); _logger.LogInformation($"[x] Event sourcing service receiving a messaged from exchange: {_hostConfig.exchange}, route :{ea.RoutingKey}."); return(true); }, (ex) => { switch (ex) { case TypeLoadException typeEx: return(true); default: return(false); } }); }; //bind event handler channel.BasicConsume(queue: queueName, autoAck: false, consumer: consumer); } catch (Exception ex) { _logger.LogError("Failed to initialize RabbitMQSubscriberWorker", ex); throw ex; } }
private void ChangedSubnet(object sender, TextChangedEventArgs e) { string tag = ((TextBox)sender).Tag.ToString(); if (oac.IsFree(tag)) { string content = ((TextBox)sender).Text; string result = ""; subnetStatus = false; // if (tag == "B1") { if (Validators.IsValidAddress(content, AddressType.SubnetmaskAddress, AddressStructure.IntegerAddress)) { result = Converters.AddressIntToBin(content); SetSlash(Converters.SubnetmaskToSlash(content)); subnetStatus = true; } else { result = ""; SetSlashEmpty(); } if (txtSubnetmaskBinario.Text != result) { oac.Block("B2"); txtSubnetmaskBinario.Text = result; } } else { if (Validators.IsValidAddress(content, AddressType.SubnetmaskAddress, AddressStructure.BinaryAddress)) { result = Converters.AddressBinToInt(content); SetSlash(Converters.SubnetmaskToSlash(content)); subnetStatus = true; } else { result = ""; SetSlashEmpty(); } if (txtSubnetmaskStandard.Text != result) { oac.Block("B1"); txtSubnetmaskStandard.Text = result; } } SetErrorMessage(); } // F void SetSlash(int slash) { if (comboBoxSlash.SelectedIndex != slash) { oac.Block("B3"); comboBoxSlash.SelectedIndex = slash; } } void SetSlashEmpty() { SetSlash(0); } }
private void SetErrorMessage() { string error = null; bool fail = false; try { fail = Validators.IsValidAddressNetwork(txtIndirizzoBinario.Text, txtSubnetmaskBinario.Text); } catch { } if (fail) { } else if (!addressStatus && !subnetStatus) { error = "Impostare un indirizzo di rete e una subnetmask validi"; } else if (!addressStatus) { error = "L'indirizzo di rete inserito non è valido"; } else if (!subnetStatus) { error = "La subnetmask inserita non è valida"; } else { error = "L'indirizzo di rete non rispetta la subnetmask inserita"; } // bool before = gridError2.Visibility == Visibility.Collapsed; if (error == null) { gridError2.Visibility = Visibility.Collapsed; if (button.Visibility == Visibility.Collapsed) { button.Opacity = 0.1; button.Visibility = Visibility.Visible; Storyboard sb = this.Resources["ButtonShow"] as Storyboard; sb.Begin(); } } else { button.Visibility = Visibility.Collapsed; gridError2.Visibility = Visibility.Visible; // if (txtError.Text != error) { txtError.Text = error; Storyboard sb = this.Resources["Terremoto"] as Storyboard; sb.Begin(); } if (before) { Storyboard sb = this.Resources["Terremoto"] as Storyboard; sb.Begin(); } } }
public BindArgs(object model_, string propertyOnModel_, Validators.IValidator validator_) { m_model=model_; m_propertyOnModel_=propertyOnModel_; m_validator=validator_; }
public override void DefsLoaded() { minMoodBonus = Settings.GetHandle <int>("minMoodBonus", "EasierExpectations.MinMoodBonus.Title".Translate(), "EasierExpectations.MinMoodBonus.Desc".Translate(), 0, Validators.IntRangeValidator(1, int.MaxValue)); maxMoodBonus = Settings.GetHandle <int>("maxMoodBonus", "EasierExpectations.MaxMoodBonus.Title".Translate(), "EasierExpectations.MaxMoodBonus.Desc".Translate(), 30, Validators.IntRangeValidator(1, int.MaxValue)); SetExpectationValues(); LogExpectationValues(); Logger.Message("Loaded"); }
/// <summary> /// Initializes a new instance of the <see cref="ValidatorPredicate" /> class. /// </summary> /// <param name="id">The identifier.</param> /// <param name="priority">The priority.</param> /// <param name="eval">The eval.</param> public UserValidator(Validators id, PredicatePriority priority, Func<Rule, string, bool> eval) : base(id, priority, eval) { }
public async Task Any(ModifyValidationRules request) { var appHost = HostContext.AssertAppHost(); var feature = appHost.AssertPlugin <ValidationFeature>(); await RequestUtils.AssertAccessRoleAsync(base.Request, accessRole : feature.AccessRole, authSecret : request.AuthSecret); var utcNow = DateTime.UtcNow; var userName = (await base.GetSessionAsync()).GetUserAuthName(); var rules = request.SaveRules; if (!rules.IsEmpty()) { foreach (var rule in rules) { if (rule.Type == null) { throw new ArgumentNullException(nameof(rule.Type)); } var existingType = appHost.Metadata.FindDtoType(rule.Type); if (existingType == null) { throw new ArgumentException(@$ "{rule.Type} does not exist", nameof(rule.Type)); } if (rule.Validator == "") { rule.Validator = null; } if (rule.Condition == "") { rule.Condition = null; } if (rule.Field == "") { rule.Field = null; } if (rule.ErrorCode == "") { rule.ErrorCode = null; } if (rule.Message == "") { rule.Message = null; } if (rule.Notes == "") { rule.Notes = null; } if (rule.Field != null && TypeProperties.Get(existingType).GetAccessor(rule.Field) == null) { throw new ArgumentException(@$ "{rule.Field} does not exist on {rule.Type}", nameof(rule.Field)); } if (rule.Validator != null) { object validator; try { validator = appHost.EvalExpression(rule.Validator); if (validator == null) { throw new ArgumentException(@$ "Validator does not exist", nameof(rule.Validator)); } } catch (Exception e) { throw new ArgumentException(@$ "Invalid Validator: " + e.Message, nameof(rule.Validator)); } var validators = (validator as List <object>) ?? TypeConstants.EmptyObjectList; var firstValidator = validator is IPropertyValidator pv ? pv : validator is ITypeValidator tv ? tv : validators?.FirstOrDefault() ?? validator; if (rule.Field != null && !(firstValidator is IPropertyValidator && validators.All(v => v is IPropertyValidator))) { throw new ArgumentException(@$ "{nameof(IPropertyValidator)} is expected but was {(validators?.FirstOrDefault(v => !(v is IPropertyValidator)) ?? firstValidator).GetType().Name}", nameof(rule.Validator)); } if (rule.Field == null && !(firstValidator is ITypeValidator && validators.All(v => v is ITypeValidator))) { throw new ArgumentException(@$ "{nameof(ITypeValidator)} is expected but was {(validators?.FirstOrDefault(v => !(v is IPropertyValidator)) ?? firstValidator).GetType().Name}", nameof(rule.Validator)); } if (rule.Condition != null) { throw new ArgumentException(@$ "Only {nameof(rule.Validator)} or {nameof(rule.Condition)} can be specified, not both", nameof(rule.Condition)); } } else { if (rule.Condition == null) { throw new ArgumentNullException(nameof(rule.Validator), @$ "{nameof(rule.Validator)} or {nameof(rule.Condition)} is required"); } try { var ast = Validators.ParseCondition(appHost.ScriptContext, rule.Condition); await ast.Init().ConfigAwait(); } catch (Exception e) { var useEx = e is ScriptException se ? se.InnerException ?? e : e; throw new ArgumentException(useEx.Message, nameof(rule.Condition)); } } if (rule.CreatedBy == null) { rule.CreatedBy = userName; rule.CreatedDate = utcNow; } rule.ModifiedBy = userName; rule.ModifiedDate = utcNow; } await ValidationSource.SaveValidationRulesAsync(rules).ConfigAwait(); } if (!request.SuspendRuleIds.IsEmpty()) { var suspendRules = await ValidationSource.GetValidateRulesByIdsAsync(request.SuspendRuleIds).ConfigAwait(); foreach (var suspendRule in suspendRules) { suspendRule.SuspendedBy = userName; suspendRule.SuspendedDate = utcNow; } await ValidationSource.SaveValidationRulesAsync(suspendRules).ConfigAwait(); } if (!request.UnsuspendRuleIds.IsEmpty()) { var unsuspendRules = await ValidationSource.GetValidateRulesByIdsAsync(request.UnsuspendRuleIds).ConfigAwait(); foreach (var unsuspendRule in unsuspendRules) { unsuspendRule.SuspendedBy = null; unsuspendRule.SuspendedDate = null; } await ValidationSource.SaveValidationRulesAsync(unsuspendRules).ConfigAwait(); } if (!request.DeleteRuleIds.IsEmpty()) { await ValidationSource.DeleteValidationRulesAsync(request.DeleteRuleIds.ToArray()).ConfigAwait(); } if (request.ClearCache.GetValueOrDefault()) { await ValidationSource.ClearCacheAsync().ConfigAwait(); } }
protected override Validators.Rule InnerConfigure(Validators.Rule rule) { return rule.Required(); }
public override void DefsLoaded() { base.DefsLoaded(); if (AssemblyExists("GiddyUpMechanoids")) { GiddyUpMechanoidsLoaded = true; } if (AssemblyExists("FacialStuff")) { facialStuffLoaded = true; } List <ThingDef> allAnimals = DefUtility.getAnimals(); allAnimals = allAnimals.OrderBy(o => o.defName).ToList(); handlingMovementImpact = Settings.GetHandle <float>("handlingMovementImpact", "GUC_HandlingMovementImpact_Title".Translate(), "GUC_HandlingMovementImpact_Description".Translate(), 1.5f, Validators.FloatRangeValidator(0f, 5f)); accuracyPenalty = Settings.GetHandle <int>("accuracyPenalty", "GUC_AccuracyPenalty_Title".Translate(), "GUC_AccuracyPenalty_Description".Translate(), 10, Validators.IntRangeValidator(minPercentage, maxPercentage)); handlingAccuracyImpact = Settings.GetHandle <float>("handlingAccuracyImpact", "GUC_HandlingAccuracyImpact_Title".Translate(), "GUC_HandlingAccuracyImpact_Description".Translate(), 0.5f, Validators.FloatRangeValidator(0f, 2f)); tabsHandler = Settings.GetHandle <String>("tabs", "GUC_Tabs_Title".Translate(), "", "none"); bodySizeFilter = Settings.GetHandle <float>("bodySizeFilter", "GUC_BodySizeFilter_Title".Translate(), "GUC_BodySizeFilter_Description".Translate(), 0.8f); animalSelecter = Settings.GetHandle <DictAnimalRecordHandler>("Animalselecter", "GUC_Animalselection_Title".Translate(), "GUC_Animalselection_Description".Translate(), null); drawSelecter = Settings.GetHandle <DictAnimalRecordHandler>("drawSelecter", "GUC_Drawselection_Title".Translate(), "GUC_Drawselection_Description".Translate(), null); tabsHandler.CustomDrawer = rect => { return(DrawUtility.CustomDrawer_Tabs(rect, tabsHandler, tabNames)); }; bodySizeFilter.CustomDrawer = rect => { return(DrawUtility.CustomDrawer_Filter(rect, bodySizeFilter, false, 0, 5, highlight1)); }; animalSelecter.CustomDrawer = rect => { return(DrawUtility.CustomDrawer_MatchingAnimals_active(rect, animalSelecter, allAnimals, bodySizeFilter, "GUC_SizeOk".Translate(), "GUC_SizeNotOk".Translate())); }; bodySizeFilter.VisibilityPredicate = delegate { return(tabsHandler.Value == tabNames[0]); }; animalSelecter.VisibilityPredicate = delegate { return(tabsHandler.Value == tabNames[0]); }; drawSelecter.CustomDrawer = rect => { return(DrawUtility.CustomDrawer_MatchingAnimals_active(rect, drawSelecter, allAnimals, null, "GUC_DrawFront".Translate(), "GUC_DrawBack".Translate())); }; drawSelecter.VisibilityPredicate = delegate { return(tabsHandler.Value == tabNames[1]); }; DrawUtility.filterAnimals(ref animalSelecter, allAnimals, bodySizeFilter); DrawUtility.filterAnimals(ref drawSelecter, allAnimals, null); foreach (ThingDef td in allAnimals) { if (td.HasModExtension <DrawingOffsetPatch>()) { td.GetModExtension <DrawingOffsetPatch>().Init(); } } foreach (BiomeDef biomeDef in DefDatabase <BiomeDef> .AllDefs) { foreach (PawnKindDef animalKind in biomeDef.AllWildAnimals) { if (!animalsWithBiome.Contains(animalKind)) { animalsWithBiome.Add(animalKind); } } } foreach (PawnKindDef animalWithoutBiome in from d in DefDatabase <PawnKindDef> .AllDefs where d.RaceProps.Animal && !animalsWithBiome.Contains(d) select d) { animalsWithoutBiome.Add(animalWithoutBiome); } /* * foreach (PawnKindDef pd in DefDatabase<PawnKindDef>.AllDefs) * { * if (pd.HasModExtension<CustomMountsPatch>()) * { * pd.GetModExtension<CustomMountsPatch>().Init(); * } * } */ }
/// <summary> /// Initializes static members of the ODataPayloadElementConfigurationValidator type. /// </summary> static ODataPayloadElementConfigurationValidator() { AllValidators = new Validators(); AllValidators.Add(NonEntityCollectionValidator, ODataPayloadElementType.PrimitiveMultiValue, ODataPayloadElementType.ComplexMultiValue); AllValidators.Add(StreamPropertyValidator, ODataPayloadElementType.NamedStreamInstance); AllValidators.Add(AssociationLinkValidator, ODataPayloadElementType.NavigationPropertyInstance); AllValidators.Add(SpatialValueValidator, ODataPayloadElementType.PrimitiveValue); AllValidators.Add(ActionAndFunctionValidator, ODataPayloadElementType.EntityInstance); }
/// <summary> /// Get the reply to a question asked by end user. /// </summary> /// <param name="turnContext">Context object containing information cached for a single turn of conversation with a user.</param> /// <param name="message">Text message.</param> /// <returns>A task that represents the work queued to execute.</returns> private async Task GetQuestionAnswerReplyAsync( ITurnContext <IMessageActivity> turnContext, IMessageActivity message) { string text = message.Text?.ToLower()?.Trim() ?? string.Empty; try { var queryResult = new QnASearchResultList(); ResponseCardPayload payload = new ResponseCardPayload(); if (!string.IsNullOrEmpty(message.ReplyToId) && (message.Value != null)) { payload = ((JObject)message.Value).ToObject <ResponseCardPayload>(); } queryResult = await this.qnaServiceProvider.GenerateAnswerAsync(question : text, isTestKnowledgeBase : false, payload.PreviousQuestions?.First().Id.ToString(), payload.PreviousQuestions?.First().Questions.First()).ConfigureAwait(false); if (queryResult.Answers.First().Id != -1) { var answerData = queryResult.Answers.First(); AnswerModel answerModel = new AnswerModel(); if (Validators.IsValidJSON(answerData.Answer)) { answerModel = JsonConvert.DeserializeObject <AnswerModel>(answerData.Answer); } if (!string.IsNullOrEmpty(answerModel?.Title) || !string.IsNullOrEmpty(answerModel?.Subtitle) || !string.IsNullOrEmpty(answerModel?.ImageUrl) || !string.IsNullOrEmpty(answerModel?.RedirectionUrl)) { await turnContext.SendActivityAsync(MessageFactory.Attachment(MessagingExtensionQnaCard.GetEndUserRichCard(text, answerData))).ConfigureAwait(false); } else { await turnContext.SendActivityAsync(MessageFactory.Attachment(ResponseCard.GetCard(answerData, text, this.appBaseUri, payload))).ConfigureAwait(false); } } else { await turnContext.SendActivityAsync(MessageFactory.Attachment(UnrecognizedInputCard.GetCard(text))).ConfigureAwait(false); } } catch (Exception ex) { // Check if knowledge base is empty and has not published yet when end user is asking a question to bot. if (((ErrorResponseException)ex).Response.StatusCode == HttpStatusCode.BadRequest) { var knowledgeBaseId = await this.configurationProvider.GetSavedEntityDetailAsync(Constants.KnowledgeBaseEntityId).ConfigureAwait(false); var hasPublished = await this.qnaServiceProvider.GetInitialPublishedStatusAsync(knowledgeBaseId).ConfigureAwait(false); // Check if knowledge base has not published yet. if (!hasPublished) { this.logger.LogError(ex, "Error while fetching the qna pair: knowledge base may be empty or it has not published yet."); await turnContext.SendActivityAsync(MessageFactory.Attachment(UnrecognizedInputCard.GetCard(text))).ConfigureAwait(false); return; } } // Throw the error at calling place, if there is any generic exception which is not caught. throw; } }
/// <summary> /// For a given payload element returns a func which skips test configuration which are not allowed. /// </summary> /// <param name="payloadElement">The payload element to check.</param> /// <param name="validators">The collection of validators to use.</param> /// <returns>The func to use for skipping test configuration which are not allowed by that payload element.</returns> public static Func<TestConfiguration, bool> GetSkipTestConfiguration(ODataPayloadElement payloadElement, Validators validators) { return GetTestConfigurationLimits(payloadElement, validators).SkipTestConfiguration; }
private static async Task RequestFilterAsync(IRequest req, IResponse res, object requestDto, bool treatInfoAndWarningsAsErrors) { var requestType = requestDto.GetType(); await Validators.AssertTypeValidatorsAsync(req, requestDto, requestType); var validator = ValidatorCache.GetValidator(req, requestType); if (validator == null) { return; } using (validator as IDisposable) { if (validator is IHasTypeValidators hasTypeValidators && hasTypeValidators.TypeValidators.Count > 0) { foreach (var scriptValidator in hasTypeValidators.TypeValidators) { await scriptValidator.ThrowIfNotValidAsync(requestDto, req); } } try { var validationResult = await validator.ValidateAsync(req, requestDto); if (treatInfoAndWarningsAsErrors && validationResult.IsValid) { return; } if (!treatInfoAndWarningsAsErrors && (validationResult.IsValid || validationResult.Errors.All(v => v.Severity != Severity.Error))) { return; } var errorResponse = await HostContext.RaiseServiceException(req, requestDto, validationResult.ToException()) ?? DtoUtils.CreateErrorResponse(requestDto, validationResult.ToErrorResult()); var autoBatchIndex = req.GetItem(Keywords.AutoBatchIndex)?.ToString(); if (autoBatchIndex != null) { var responseStatus = errorResponse.GetResponseStatus(); if (responseStatus != null) { if (responseStatus.Meta == null) { responseStatus.Meta = new Dictionary <string, string>(); } responseStatus.Meta[Keywords.AutoBatchIndex] = autoBatchIndex; } } var validationFeature = HostContext.GetPlugin <ValidationFeature>(); if (validationFeature?.ErrorResponseFilter != null) { errorResponse = validationFeature.ErrorResponseFilter(req, validationResult, errorResponse); } await res.WriteToResponse(req, errorResponse); } catch (Exception ex) { var validationEx = ex.UnwrapIfSingleException(); var errorResponse = await HostContext.RaiseServiceException(req, requestDto, validationEx) ?? DtoUtils.CreateErrorResponse(requestDto, validationEx); await res.WriteToResponse(req, errorResponse); } } }
/// <summary> /// Initializes a new instance of the <see cref="ValidatorPredicate"/> class. /// </summary> /// <param name="id">The identifier.</param> /// <param name="priority">The priority.</param> /// <param name="eval">The eval.</param> public ValidatorPredicate(Validators id, PredicatePriority priority, Func<Rule, string, bool> eval) { _id = id; _evaluator = eval; Priority = priority; }
private static void RunInputSample() { var name = Prompt.Input <string>("What's your name?", validators: new[] { Validators.Required(), Validators.MinLength(3) }); Console.WriteLine($"Hello, {name}!"); }
protected override Validators.Rule InnerConfigure(Validators.Rule rule) { return rule.IsInRange(Min, Max); }
public void Bind(object model_, string propertyOnModel_, Validators.IValidator validator_) { Bind("Value",model_,propertyOnModel_,validator_); }