protected override Task <TProxy> GetRecordValue(IAttributeResolver attributeResolver)
{
var result = new TProxy();
result.SetData(_source);
return(Task.FromResult(result));
}
protected override async Task <RateLimits> GetRecordValue(IAttributeResolver attributeResolver)
{
IReadOnlyCollection <string> subscriptionValues = await attributeResolver.Resolve <string>(subscriptionLevel);
if (subscriptionValues.Count == 0)
{
return(new RateLimits());
}
IReadOnlyCollection <string> currentRequestValues = await attributeResolver.Resolve <string>(currentRequestsFromQuery);
long currentRequests = 0;
if (currentRequestValues.Count > 0)
{
if (long.TryParse(currentRequestValues.First(), out long parsedValue))
{
currentRequests = parsedValue;
}
}
long maxRequests = rateLimitMap[subscriptionValues.First()];
return(new RateLimits
{
MaxRequestsPerDay = maxRequests,
CurrentRequestsPerDay = currentRequests
});
}
protected override async Task <FinanceDepartmentLimits> GetRecordValue(IAttributeResolver attributeResolver)
{
// Retrieve the department from the evaluation context
IReadOnlyCollection <string> departments = await attributeResolver.Resolve <string>(Department);
double purchaseOrderLimit = 0;
switch (departments.Single())
{
case "engineering": purchaseOrderLimit = 500;
break;
case "finance": purchaseOrderLimit = 2000;
break;
}
return(new FinanceDepartmentLimits()
{
MaxPurchaseOrder = purchaseOrderLimit
});
}
public void Analyze(StemDefinition destination, Type stemType)
{
Type stemBaseType = stemType.GetGenericSubclass(typeof(Stem <>))
?? throw new StemAttributeSetupException("Stem attributes applied to a class that does not derive from Stem<>.");
Type itemType = stemBaseType.GetGenericArguments()[0];
foreach (MemberInfo member in stemType.GetMembers(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public))
{
foreach (StemAttribute stemAttribute in member.GetCustomAttributes <StemAttribute>())
{
IAttributeResolver resolver = stemAttribute.GetResolver();
resolver.Attribute = stemAttribute;
resolver.Definition = destination;
resolver.ItemType = itemType;
resolver.PropertyAutoMapper = _propertyAutoMapper;
resolver.IncludeMember(member);
}
}
}
public async ValueTask <AttributeValueResult <T> > GetValue <T>(PolicyAttribute attribute,
IAttributeResolver attributeResolver,
IEnforcerLogger evaluationLogger)
{
if (attribute == null)
{
throw new ArgumentNullException(nameof(attribute));
}
if (attribute.RuntimeType != typeof(T))
{
evaluationLogger.LogError(
$"{GetType().Name}: Requested attribute {attribute} does not match type requested {typeof(T).Name}");
throw new ArgumentException("Requested attribute does not match type requested", nameof(attribute));
}
// Iterate through value providers and aggregate their results
var sensitivity = PolicyAttributeSensitivity.NonSensitive;
var values = Enumerable.Empty <T>();
var foundValues = false;
foreach (var provider in _valueProviders)
{
var valueResult = await provider.GetValue <T>(attribute, attributeResolver, evaluationLogger);
sensitivity = MostSensitive(sensitivity, valueResult.Sensitivity);
if (valueResult.HasValues)
{
values = values.Concat(valueResult.Values);
foundValues = true;
}
}
return(foundValues
? new AttributeValueResult <T>(values.ToArray(), sensitivity)
: AttributeValueResult <T> .CacheableEmpty);
}
public string Calculate(IAttributeResolver person)
{
return($"{person.GetAttributeValue<string>("firstname")} {person.GetAttributeValue<string>("lastname")}");
}
protected override Task <ActionAttributeValueProvider> GetRecordValue(IAttributeResolver attributeResolver)
{
return(Task.FromResult(this));
}
