public void GetProperty_will_throw_on_invalid_property_name(IPropertyProvider pp)
{
Assert.Throws <ArgumentException>(() => pp.GetProperty(""));
Assert.Throws <ArgumentException>(() => pp.GetProperty(null));
Assert.Throws <ArgumentException>(() => pp.TryGetProperty("", typeof(object), out _));
Assert.Throws <ArgumentException>(() => pp.TryGetProperty(null, typeof(object), out _));
}
public Task <TProperty> GetProperty <T>(InitializeContext <T, TInput> context)
where T : class
{
if (!context.TryGetPayload <TransformContext <TInput> >(out TransformContext <TInput> transformContext))
{
return(TaskUtil.Default <TProperty>());
}
if (!context.HasInput)
{
return(TaskUtil.Default <TProperty>());
}
Task <TProperty> inputTask = _inputProvider.GetProperty(context);
if (inputTask.IsCompleted)
{
var propertyContext = new MessageTransformPropertyContext <TProperty, TInput>(transformContext, inputTask.Result);
return(_valueProvider(propertyContext));
}
async Task <TProperty> GetPropertyAsync()
{
var inputValue = await inputTask.ConfigureAwait(false);
var propertyContext = new MessageTransformPropertyContext <TProperty, TInput>(transformContext, inputValue);
return(await _valueProvider(propertyContext).ConfigureAwait(false));
}
return(GetPropertyAsync());
}
public Task Apply(InitializeContext <TMessage, TInput> context)
{
Task <TProperty> propertyTask = _propertyProvider.GetProperty(context);
if (propertyTask.IsCompleted)
{
if (_messageProperty.TargetType == context.MessageType)
{
_messageProperty.Set(context.Message, propertyTask.Result);
}
return(TaskUtil.Completed);
}
async Task ApplyAsync()
{
var propertyValue = await propertyTask.ConfigureAwait(false);
if (_messageProperty.TargetType == context.MessageType)
{
_messageProperty.Set(context.Message, propertyValue);
}
}
return(ApplyAsync());
}
public Task <Task <TProperty> > GetProperty <T>(InitializeContext <T, TInput> context)
where T : class
{
return(Task.FromResult(context.HasInput
? _provider.GetProperty(context)
: TaskUtil.Default <TProperty>()));
}
Task <TProperty> IPropertyProvider <TInput, TProperty> .GetProperty <T>(InitializeContext <T, TInput> context)
{
if (!context.HasInput)
{
return(TaskUtil.Default <TProperty>());
}
Task <Task <TProperty> > propertyTask = _provider.GetProperty(context);
if (propertyTask.IsCompleted)
{
Task <TProperty> valueTask = propertyTask.Result;
if (valueTask.IsCompleted)
{
return(valueTask);
}
}
async Task <TProperty> GetPropertyAsync()
{
Task <TProperty> valueTask = await propertyTask.ConfigureAwait(false);
return(await valueTask.ConfigureAwait(false));
}
return(GetPropertyAsync());
}
public void Apply(TInput result, TransformContext <TInput> context)
{
if (context.HasInput)
{
TProperty value = _propertyProvider.GetProperty(context);
_property.Set(result, value);
}
}
public static DateTime GetDateTime(this IPropertyProvider source, string property)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
return(Convert.ToDateTime(source.GetProperty(property)));
}
public static int GetInt32(this IPropertyProvider source, string property)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
return(Convert.ToInt32(source.GetProperty(property)));
}
public static T GetProperty <T>(this IPropertyProvider source, string property)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
return(source.GetProperty <T>(property, default(T)));
}
/// <summary>
/// Creates a new IssueReportService with the default report backends (github and soon email)
/// </summary>
/// <param name="configuration"></param>
/// <param name="stackTraceProvider"></param>
public IssueReportService(IPropertyProvider configuration, IStackTraceProvider stackTraceProvider)
{
if (configuration == null) throw new ArgumentNullException("configuration");
_stackTraceProvider = stackTraceProvider;
ActiveBackend = configuration.GetProperty("locco.backend");
RegisterKnownProviders(configuration);
}
public static object GetProperty(this IPropertyProvider source, string property)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
return(source.GetProperty <object>(property, null));
}
public static bool GetBoolean(this IPropertyProvider source, string property)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
var value = source.GetProperty(property);
return(Convert.ToBoolean(value));
}
public Task Apply(InitializeContext <TMessage, TInput> context, SendContext sendContext)
{
var propertyTask = _propertyProvider.GetProperty(context);
if (propertyTask.IsCompleted)
{
_messageProperty.Set(sendContext, propertyTask.Result);
return(TaskUtil.Completed);
}
return(ApplyAsync(sendContext, propertyTask));
}
public Task <MessageData <TValue> > GetProperty <T>(InitializeContext <T, TInput> context)
where T : class
{
if (!context.HasInput)
{
return(TaskUtil.Default <MessageData <TValue> >());
}
Task <MessageData <TValue> > inputTask = _inputProvider.GetProperty(context);
if (inputTask.IsCompleted)
{
MessageData <TValue> messageData = inputTask.Result;
if (messageData is IInlineMessageData)
{
return(Task.FromResult(messageData));
}
if (messageData?.Address != null)
{
var repository = _repository;
if (repository != null || context.TryGetPayload(out repository))
{
return(Task.FromResult(_reader.GetMessageData(repository, messageData.Address, context.CancellationToken)));
}
}
return(Task.FromResult(EmptyMessageData <TValue> .Instance));
}
async Task <MessageData <TValue> > GetPropertyAsync()
{
MessageData <TValue> messageData = await inputTask.ConfigureAwait(false);
if (messageData is IInlineMessageData)
{
return(messageData);
}
if (messageData?.Address != null)
{
var repository = _repository;
if (repository != null || context.TryGetPayload(out repository))
{
return(_reader.GetMessageData(repository, messageData.Address, context.CancellationToken));
}
}
return(EmptyMessageData <TValue> .Instance);
}
return(GetPropertyAsync());
}
public PropertyItem GetProperty(IPropertyProvider _, ProcessorItem item, string propertyName)
{
foreach (IPropertyProvider propertyProvider in propertyProviders)
{
PropertyItem property = propertyProvider.GetProperty(this, item, propertyName);
if (property != null)
{
return(property);
}
}
return(fallbackProvider?.GetProperty(this, item, propertyName));
}
public async Task <IActionResult> Get(int landlordId, int id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var item = await _provider.GetProperty(landlordId, id);
if (item == null)
{
return(NotFound()); //404 Not Found (Client Error Status Code)
}
return(Ok(item)); //Get Successfull (Success Status Code)
}
public Task <TProperty> GetProperty <T>(InitializeContext <T, TInput> context)
where T : class
{
var inputTask = _inputProvider.GetProperty(context);
if (inputTask.IsCompleted)
{
return(context.HasInput
? _converter.Convert(context, inputTask.Result)
: TaskUtil.Default <TProperty>());
}
return(GetPropertyAsync(context, inputTask));
}
public async Task <IEnumerable <TElement> > GetProperty <T>(InitializeContext <T, TInput> context)
where T : class
{
if (context.HasInput)
{
var propertyValue = await _provider.GetProperty <T>(context).ConfigureAwait(false);
if (propertyValue != default)
{
return(propertyValue);
}
}
return(Enumerable.Empty <TElement>());
}
static object Eval(IPropertyProvider pp, string tokenName)
{
object result = pp.GetProperty(tokenName);
Delegate d = result as Delegate;
if (d == null)
{
return(result);
}
var type = d.GetType().GetTypeInfo();
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Func <,>))
{
return(d.DynamicInvoke(tokenName));
}
return(d.DynamicInvoke(null));
}
public Task Apply(InitializeContext <TMessage, TInput> context, SendContext sendContext)
{
Task <THeader> propertyTask = _provider.GetProperty(context);
if (propertyTask.IsCompleted)
{
sendContext.Headers.Set(_headerName, propertyTask.Result);
return(TaskUtil.Completed);
}
async Task ApplyAsync()
{
var value = await propertyTask.ConfigureAwait(false);
sendContext.Headers.Set(_headerName, value);
}
return(ApplyAsync());
}
public static DateTimeOffset GetDateTimeOffset(this IPropertyProvider source, string property)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
object value = source.GetProperty(property);
switch (value)
{
case DateTime dt:
return(new DateTimeOffset(dt));
case DateTimeOffset res:
return(res);
default:
return(DateTimeOffset.Parse(value.ToString()));
}
}
public Task <TProperty?> GetProperty <T>(InitializeContext <T, TInput> context)
where T : class
{
if (context.HasInput)
{
var propertyTask = _provider.GetProperty(context);
if (propertyTask.IsCompleted)
{
return(Task.FromResult <TProperty?>(propertyTask.Result));
}
async Task <TProperty?> GetPropertyAsync()
{
return(await propertyTask.ConfigureAwait(false));
}
return(GetPropertyAsync());
}
return(TaskUtil.Default <TProperty?>());
}
public Task <MessageData <TValue> > GetProperty <T>(InitializeContext <T, TInput> context)
where T : class
{
if (!context.HasInput)
{
return(TaskUtil.Default <MessageData <TValue> >());
}
Task <MessageData <TValue> > inputTask = _inputProvider.GetProperty(context);
if (inputTask.IsCompleted)
{
MessageData <TValue> messageData = inputTask.Result;
if (messageData is PutMessageData <TValue> putMessageData && putMessageData.HasValue)
{
return(Put(context, putMessageData.Value));
}
if (messageData is IInlineMessageData && messageData.HasValue && messageData.Address == null)
{
return(Put(context, messageData.Value));
}
return(Task.FromResult(messageData));
}
async Task <MessageData <TValue> > GetPropertyAsync()
{
MessageData <TValue> messageData = await inputTask.ConfigureAwait(false);
if (messageData is PutMessageData <TValue> putMessageData && putMessageData.HasValue)
{
return(await Put(context, putMessageData.Value));
}
return(messageData);
}
return(GetPropertyAsync());
}
public async Task <IEnumerable <TElement> > GetProperty <T>(InitializeContext <T, TInput> context)
where T : class
{
if (context.HasInput)
{
IEnumerable <TInputElement> propertyValue = await _provider.GetProperty(context).ConfigureAwait(false);
if (propertyValue != null)
{
var results = new List <TElement>();
foreach (var element in propertyValue)
{
var result = await _converter.Convert(context, element).ConfigureAwait(false);
results.Add(result);
}
return(results);
}
}
return(Enumerable.Empty <TElement>());
}
public Task <TProperty> GetProperty <T>(InitializeContext <T, TInput> context)
where T : class
{
if (!context.HasInput)
{
return(TaskUtil.Default <TProperty>());
}
var inputTask = _inputProvider.GetProperty(context);
if (inputTask.IsCompleted)
{
return(_converter.Convert(context, inputTask.Result));
}
async Task <TProperty> GetPropertyAsync()
{
var inputValue = await inputTask.ConfigureAwait(false);
return(await _converter.Convert(context, inputValue).ConfigureAwait(false));
}
return(GetPropertyAsync());
}
public Task Apply(InitializeContext <TMessage, TInput> context)
{
return(_propertyProvider.GetProperty(context));
}
static object Eval(IPropertyProvider pp, string tokenName)
{
object result = pp.GetProperty(tokenName);
Delegate d = result as Delegate;
if (d == null)
return result;
else
return d.DynamicInvoke(null);
}
public async Task Apply(InitializeContext <TMessage, TInput> context)
{
var propertyValue = await _propertyProvider.GetProperty(context).ConfigureAwait(false);
_messageProperty.Set(context.Message, propertyValue);
}
