public ArgumentsRule(
Func <AppliedOption, string> validate,
IReadOnlyCollection <string> allowedValues = null,
Func <string> defaultValue = null,
string description = null,
string name = null,
Func <ParseResult, IEnumerable <string> > suggest = null)
{
if (validate == null)
{
throw new ArgumentNullException(nameof(validate));
}
this.defaultValue = new Lazy <string>(defaultValue ?? (() => null));
Description = description;
Name = name;
this.validate = validate;
if (suggest == null)
{
this.suggest = result =>
AllowedValues.FindSuggestions(result);
}
else
{
this.suggest = result =>
suggest(result).ToArray()
.FindSuggestions(
result.TextToMatch());
}
AllowedValues = allowedValues ?? Array.Empty <string>();
}
/// <inheritdoc />
public Task Authorize(AuthorizationContext context)
{
bool found = false;
if (context.User != null)
{
if (AllowedValues == null || !AllowedValues.Any())
{
found = context.User.Claims.Any(
claim => string.Equals(claim.Type, ClaimType, StringComparison.OrdinalIgnoreCase));
}
else
{
found = context.User.Claims.Any(
claim => string.Equals(claim.Type, ClaimType, StringComparison.OrdinalIgnoreCase) &&
AllowedValues.Contains(claim.Value, StringComparer.Ordinal));
}
}
if (!found)
{
if (AllowedValues != null && AllowedValues.Any())
{
string values = string.Join(", ", DisplayValues ?? AllowedValues);
context.ReportError($"Required claim '{ClaimType}' with any value of '{values}' is not present.");
}
else
{
context.ReportError($"Required claim '{ClaimType}' is not present.");
}
}
return(Task.CompletedTask);
}
private string BuildButton(WorkItemStatus statusValue)
{
var classes = new List <string>()
{
"ui", "button"
};
var isCurrentValue = false;
if (CurrentValue.HasValue)
{
if (CurrentValue == statusValue)
{
classes.Add("active");
isCurrentValue = true;
}
}
else
{
if (statusValue == DefaultValue)
{
classes.Add("active");
isCurrentValue = true;
}
}
if (AllowedValues != null && !AllowedValues.Contains(statusValue) && !isCurrentValue)
{
classes.Add("disabled");
}
var buttonTemplate = $"<button type=\"button\" data-status=\"{statusValue}\" class=\"{string.Join(" ", classes)}\">{statusValue.GetDisplayName()}</button>";
return(buttonTemplate);
}
public DocumentAttribute Mutate(string onInvalid, string description)
{
return(new DocumentAttribute(Name,
AllowedRegExps.ToList(),
AllowedValues.ToList(),
!string.IsNullOrEmpty(onInvalid) ? onInvalid : OnInvalid,
!string.IsNullOrEmpty(description) ? description : Description));
}
/// <inheritdoc />
public override string ToString()
{
var value = (AllowedValues == null || !AllowedValues.Any())
? string.Empty
: $" and `{ClaimConstants.Scp}` or `{ClaimConstants.Scope}` is one of the following values: ({string.Join("|", AllowedValues)})";
return($"{nameof(ScopeAuthorizationRequirement)}:Scope={value}");
}
public void ValidatePredictionValue_Pass()
{
AllowedValues.ValidatePredictionValue("", "");
AllowedValues.ValidatePredictionValue(".", "");
AllowedValues.ValidatePredictionValue("P", "");
AllowedValues.ValidatePredictionValue("Likely Benign", "");
AllowedValues.ValidatePredictionValue("Vus", "");
}
/// <summary>
/// Проверить значение, уже десериализованное, на вхождение в AllowedValues
/// </summary>
void CheckByAllowedValues(object value, string valueSrc, bool isFromCmd)
{
if (AllowedValues?.Length > 0 &&
AllowedValues.Where(x => x != null).All(x => !CompareWithAllowedValue(value, x)))
{
string e = $"Argument [{Name}]: value [{valueSrc}] is not allowed";
throw isFromCmd ? (Exception) new CmdException(e) : new ConfException(e);
}
}
public void Sanitize(Value value)
{
value.FieldName = Name ?? string.Empty;
string sanitizedValue = TrimField ? value.OriginalValue.Trim()
: value.OriginalValue;
//If it wasn't in the original file, handle it in advance
if (value.Missing || sanitizedValue == string.Empty)
{
if (!AllowedBlank)
{
value.ErrorMsg = ValueIfBlank;
}
return;
}
//Removes any disallowed characters and retains only allowed characters
var chars = sanitizedValue.ToCharArray();
if (AllowedCharacters.Any())
{
chars = chars.Where(c => AllowedCharacters.Any(a => a == c)).ToArray();
}
if (DisallowedCharacters.Any())
{
chars = chars.Where(c => !DisallowedCharacters.Any(d => d == c)).ToArray();
}
//validate the length
if (chars.Length > MaxLength ||
chars.Length < MinLength)
{
value.SanitizedValue = new string(chars);
value.ErrorMsg = ValueIfWrongLength;
return;
}
//run regex
sanitizedValue = new string(chars);
if (RegEx != string.Empty && !Regex.IsMatch(sanitizedValue, RegEx))
{
value.ErrorMsg = "Value failed regex check on value.";
return;
}
//run any custom checks
value.SanitizedValue = RemoveDoubleSpaces(sanitizedValue); //remove any double spaces
CustomChecks.ForEach(c => c.Execute(value));
//If this there are a fixed number of options, check for them
if ((AllowedValues?.Count() ?? 0) != 0 &&
!AllowedValues.Any(v => v == value.SanitizedValue))
{
value.ErrorMsg = ValueIfNotInAllowedOptions;
}
}
public override void ToggleValue()
{
try
{
var currentIndex = AllowedValues.IndexOf(Value);
var newIndex = currentIndex + 1 >= AllowedValues.Count ? 0 : currentIndex + 1;
Value = AllowedValues[newIndex];
}
catch
{
Value = (string)DefaultValue;
}
}
public string MatcherRegEx(bool hasNext)
{
// <p (id=#([0-9.*{6})|sdf).*>
var regExp = new StringBuilder();
regExp.Append(Name)
.Append(Consts.ANY_NORMAL_WHITESPACES)
.Append("=")
.Append(Consts.ANY_NORMAL_WHITESPACES)
.Append("\"")
.Append(Consts.OPEN_ATTRIBUTE);
bool hasRegExps = AllowedRegExps.Any();
if (AllowedRegExps.Count() + AllowedValues.Count() > 0)
{
foreach (string allowedValue in AllowedValues)
{
regExp.Append(DocumentTag.EscapeRegularExpressionCharacters(allowedValue));
if (AllowedValues.Last() != allowedValue || hasRegExps)
{
regExp.Append(Consts.ATTRIBUTE_DIVIDER);
}
}
foreach (string allowedRegExp in AllowedRegExps)
{
regExp.Append(allowedRegExp);
if (AllowedRegExps.Last() != allowedRegExp)
{
regExp.Append(Consts.ATTRIBUTE_DIVIDER);
}
}
if (this.AllowedRegExps.Count() + this.AllowedValues.Count() > 0)
{
regExp.Append(Consts.CLOSE_ATTRIBUTE);
}
regExp.Append("\"" + Consts.ANY_NORMAL_WHITESPACES);
if (hasNext)
{
regExp.Append(Consts.ATTRIBUTE_DIVIDER);
}
}
return(regExp.ToString());
}
public bool IsValidForCharacter([NotNull] CharacterInfo character)
{
if (character == null)
{
throw new ArgumentNullException(nameof(character));
}
var fieldValues = character.Fields.SingleOrDefault(f => f.FieldId == FieldId)?.FieldValue?.Split(',');
var allowByField = FieldId == 0 || AllowedValues.Intersect(fieldValues ?? Enumerable.Empty <string>()).Any();
var allowByGroup = ShowForGroups.Length == 0 ||
ShowForGroups.Intersect(character.Groups.Select(g => g.CharacterGroupId)).Any();
var disallowByGroup = SkipForGroups.Intersect(character.Groups.Select(g => g.CharacterGroupId)).Any();
return(allowByField && allowByGroup && !disallowByGroup);
}
private HashSet <object> GetAllowedValues(ValidationContext validationContext)
{
if (AllowedValuesProvider is null)
{
return(AllowedValues.ToHashSet());
}
var instance = validationContext.ObjectInstance;
var type = instance.GetType();
var member = type.GetMember(
AllowedValuesProvider,
MemberTypes.Field | MemberTypes.Property | MemberTypes.Method,
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static
)
.FirstOrDefault();
if (member is null)
{
throw new ArgumentException(
$"{nameof(AllowedValuesProvider)} must reference a field or method in {type.FullName}",
AllowedValuesProvider
);
}
var providedValues = member.MemberType switch
{
MemberTypes.Field => ((FieldInfo)member).GetValue(instance),
MemberTypes.Property => ((PropertyInfo)member).GetValue(instance),
MemberTypes.Method => ((MethodInfo)member).Invoke(instance, new object?[] { }),
_ => throw new ArgumentOutOfRangeException(
$"{nameof(AllowedValuesProvider)} is not a valid member on {type.FullName}",
AllowedValuesProvider
)
};
if (providedValues is not IEnumerable <object> providedAllowedValues)
{
throw new ArgumentException(
$"{nameof(AllowedValuesProvider)} on {type.FullName} must implement {nameof(IEnumerable)}",
AllowedValuesProvider
);
}
return(AllowedValues
.Concat(providedAllowedValues)
.ToHashSet());
}
}
public string this[string columnName]
{
get
{
string msg = null;
if (string.IsNullOrEmpty(To) || string.IsNullOrWhiteSpace(To))
{
msg = "соответствие не может быть пустым";
}
else if (AllowedValues.Count > 0 && !AllowedValues.Contains(To))
{
msg = "введено нестандартное значение";
}
return(msg);
}
}
public MappingsContainer CopyFrom(MappingsContainer source)
{
this.Owner = source.Owner;
this.AbsoluteCoincidence = source.AbsoluteCoincidence;
this.Clear();
foreach (var item in source)
{
Add((new Mapping()).CopyFrom(item));
}
AllowedValues.Clear();
foreach (var item in source.AllowedValues)
{
AllowedValues.Add(item);
}
return(this);
}
private bool IsAttributeValid(string attributeName, string value)
{
if (AllowedAttributes != null)
{
// No attributes are allowed
if (!AllowedAttributes.Any())
{
return(false);
}
if (!AllowedAttributes.Contains(attributeName))
{
return(false);
}
}
if (RequiredAttributes != null)
{
if (value == null && RequiredAttributes.Contains(attributeName))
{
// Don't delete any required attributes
return(false);
}
}
if (AllowedValues != null)
{
if (AllowedValues.TryGetValue(attributeName, out var allowed) && !allowed.Contains(value.Trim()))
{
return(false);
}
}
if (DisallowedValues != null)
{
if (DisallowedValues.TryGetValue(attributeName, out var disallowed) && disallowed.Contains(value.Trim()))
{
return(false);
}
}
return(true);
}
private bool _IsSimple()
{
var byNumTrue = AllowedValues
.GroupBy(av => av.Count(av => av));
if (byNumTrue.Count() != 2)
{
return(false);
}
if (byNumTrue.SingleOrDefault(bnt => bnt.Key == 9)?.Count() != 13)
{
return(false);
}
if (byNumTrue.SingleOrDefault(bnt => bnt.Key == 1)?.Count() != 1)
{
return(false);
}
return(true);
}
public int ToIntValue()
{
return(AllowedValues.IndexOf(Value));
}
public MySettingsController()
{
Get("/api/v1/me/setting/get", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "key" }),
}, true);
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var settingKey = GetRequestStr("key");
if (!AllowedValues.GetAllowed().ContainsKey(settingKey))
{
new HttpError(HttpStatusCode.UnprocessableEntity, "This setting key is not allowed");
}
var me = UserRepository.Find(CurrentRequest.UserId);
var setting = UserSetting.Find(me, settingKey);
setting ??= UserSettingRepository.SetSetting(me, settingKey, "");
return(HttpResponse.Item("setting", new UserSettingTransformer().Transform(setting)));
});
Get("/api/v1/me/settings/get", _ => {
var me = UserRepository.Find(CurrentRequest.UserId);
var settings = UserSettingRepository.Get(me);
return(HttpResponse.Item("settings", new UserSettingTransformer().Many(settings)));
});
Patch("/api/v1/me/setting/set", _ => {
var errors = ValidationProcessor.Process(Request, new IValidatorRule[] {
new ShouldHaveParameters(new[] { "key", "value" }),
}, true);
if (errors.Count > 0)
{
return(HttpResponse.Errors(errors));
}
var settingKey = GetRequestStr("key");
if (!AllowedValues.GetAllowed().ContainsKey(settingKey))
{
return(HttpResponse.Error(
new HttpError(HttpStatusCode.UnprocessableEntity, "This setting key is not allowed")
));
}
var settingValue = GetRequestStr("value");
if (
AllowedValues.GetAllowed()[settingKey] != null &&
!AllowedValues.GetAllowed()[settingKey].Contains(settingValue)
)
{
return(HttpResponse.Error(new HttpError(HttpStatusCode.Forbidden,
"This setting value is not allowed")));
}
var me = UserRepository.Find(CurrentRequest.UserId);
var setting = UserSettingRepository.SetSetting(
me, settingKey, GetRequestStr("value")
);
return(HttpResponse.Item("setting", new UserSettingTransformer().Transform(setting)));
});
}
public void IsEmptyValue_AsExpected()
{
Assert.True(AllowedValues.IsEmptyValue(""));
Assert.True(AllowedValues.IsEmptyValue("."));
Assert.False(AllowedValues.IsEmptyValue("-"));
}
public void ValidatePredictionValue_ThrowException()
{
Assert.Throws <UserErrorException>(() => AllowedValues.ValidatePredictionValue("LikelyBenign", ""));
Assert.Throws <UserErrorException>(() => AllowedValues.ValidatePredictionValue("Likely Benign, LB", ""));
}
public override bool IsValid(object?value) => AllowedValues.Contains(value?.ToString());
public IModSetting ToSetting(IHasModSettings owner)
{
switch (Type)
{
case SettingType.Boolean:
return(new BooleanModSetting(owner, Name, LoadTime, Ordering, DefaultValue.GetBoolean()));
case SettingType.Integer:
if ((AllowedValues == null) || (AllowedValues.Length == 0))
{
return(new IntegerModSetting(owner, Name, LoadTime, Ordering, DefaultValue.GetInteger(), MinValue?.GetInteger() ?? long.MinValue, MaxValue?.GetInteger() ?? long.MaxValue));
}
else
{
return(new IntegerListModSetting(owner, Name, LoadTime, Ordering, DefaultValue.GetInteger(), AllowedValues.Select(value => value.GetInteger())));
}
case SettingType.FloatingPoint:
if ((AllowedValues == null) || (AllowedValues.Length == 0))
{
return(new FloatingPointModSetting(owner, Name, LoadTime, Ordering, DefaultValue.GetFloatingPoint(), MinValue?.GetFloatingPoint() ?? decimal.MinValue, MaxValue?.GetFloatingPoint() ?? decimal.MaxValue));
}
else
{
return(new FloatingPointListModSetting(owner, Name, LoadTime, Ordering, DefaultValue.GetFloatingPoint(), AllowedValues.Select(value => value.GetFloatingPoint())));
}
case SettingType.String:
if ((AllowedValues == null) || (AllowedValues.Length == 0))
{
return(new StringModSetting(owner, Name, LoadTime, Ordering, DefaultValue.GetString(), AllowEmptyValue));
}
else
{
return(new StringListModSetting(owner, Name, LoadTime, Ordering, DefaultValue.GetString(), AllowedValues.Select(value => value.GetString())));
}
}
return(null);
}
/// <summary>
/// Creates a new PlayingCard instance
/// </summary>
/// <param name="value">The card's value</param>
/// <param name="suit">The card's suit</param>
public PlayingCard(AllowedValues value, AllowedSuits suit)
{
Value = value;
Suit = suit;
}
/// <summary>
/// Retrive the string counterpart to the AllowedValues enum value
/// </summary>
/// <param name="value">Card value from AllowedValues</param>
/// <returns>String representing the provided value</returns>
public static string GetValueString(AllowedValues value)
{
return(ValueStrings[(int)value]);
}
public AcColumnInfo AddAllowedValue(string[] InValues)
{
AllowedValues.AddRange(InValues);
return(this);
}
public void LoadAllowedValues(string[] values)
{
if (values == null)
{
return;
}
AllowedValues.Clear();
if (Owner.FieldName == "Размер")
{
foreach (var value in values)
{
var sizes = Settings.SettingsProvider.AllowedSizes.Where(s => s.Name == value).ToArray();
foreach (var size in sizes)
{
var type = Settings.SettingsProvider.AllowedTypes.Where(t => t.Id == size.FkTypeId).FirstOrDefault();
if (type != null)
{
AllowedValues.Add(value + " (" + type.Name + ")");
}
}
}
}
else if (Owner.FieldName == "Район")
{
List <string> regionsAdded = new List <string>();
var cities = Settings.SettingsProvider.AllowedCities.OrderBy(item => item.Name).ToArray();
var regionsForCities = Settings.SettingsProvider.AllowedRegions.Where(r => values.Contains(r.Name) && cities.Any(city => r.FkCityId == city.Id)).ToArray();
foreach (var city in cities)
{
var regions = regionsForCities.Where(r => r.FkCityId == city.Id).ToArray();
foreach (var region in regions)
{
regionsAdded.Add(region.Name);
AllowedValues.Add(region.Name + " (" + city.Name + ")");
}
}
foreach (var value in values.Where(val => !regionsAdded.Contains(val)))
{
AllowedValues.Add(value);
}
//foreach (var value in values)
//{
// var regions = Settings.SettingsProvider.AllowedRegions.Where(r => r.Name == value).ToArray();
// foreach (var region in regions)
// {
// var city = Settings.SettingsProvider.AllowedCities.Where(c => c.Id == region.FkCityId).FirstOrDefault();
// AllowedValues.Add(value + " (" + city.Name + ")");
// }
//}
}
else
{
foreach (var value in values)
{
AllowedValues.Add(value);
}
}
}
/// <summary>
/// List of field's available allowed values as object of class T which is ought to be implemented by user of this method.
/// Conversion from serialized JObject to custom class T takes here place.
/// </summary>
public IEnumerable <T> AllowedValuesAs <T>()
{
return(AllowedValues.Values <JObject>().Select(x => x.ToObject <T>()));
}
