public Task <IValueProvider> BindAsync(TBindingData value, ValueBindingContext context)
{
object converted = _converter.Convert(value);
IValueProvider provider = new ObjectValueProvider(converted, typeof(string));
return(Task.FromResult(provider));
}
public void ApplyTo(T obj, ObjectValueProvider valueProvider)
{
ArrayValueProvider values;
if (!valueProvider.TryGetValue(_property.Property.Name, out values))
{
return;
}
var elements = new Dictionary <TKey, TValue>();
for (int i = 0;; i++)
{
ArrayValueProvider elementArray;
if (!values.TryGetValue(i, out elementArray))
{
break;
}
TKey elementKey;
if (elementArray.TryGetValue(0, out elementKey))
{
TValue elementValue = default(TValue);
ObjectValueProvider elementValueProvider;
if (elementArray.TryGetValue(1, out elementValueProvider))
{
elementValue = (TValue)_valueConverter.GetObject(elementValueProvider);
}
elements[elementKey] = elementValue;
}
}
_property.Set(obj, elements);
}
public void ApplyTo(T obj, ObjectValueProvider valueProvider)
{
ArrayValueProvider values;
if (!valueProvider.TryGetValue(_property.Property.Name, out values))
{
return;
}
var elements = new List <TElement>();
for (int i = 0;; i++)
{
ObjectValueProvider elementValueProvider;
if (!values.TryGetValue(i, out elementValueProvider))
{
break;
}
var element = (TElement)_converter.GetObject(elementValueProvider);
elements.Add(element);
}
_property.Set(obj, elements);
}
public void CtorTest()
{
var actual = new ObjectValueProvider(new TestModel());
actual.Should()
.NotBeNull();
}
public void GetValueInvalidExpressionTest()
{
var model = InstanceCreator.CreateInstance <TestModel>();
var target = new ObjectValueProvider(model);
Action test = () => target.GetValue("DOESNotExist");
test.ShouldThrow <FormatException>();
}
public void GetValueTest3()
{
var model = InstanceCreator.CreateInstance <TestModel>();
var target = new ObjectValueProvider(model);
var actual = target.GetValue("MyStringArray[0]");
actual.Should()
.Be(model.MyStringArray[0]);
}
public void GetValueTest2()
{
var model = InstanceCreator.CreateInstance <TestModel>();
var target = new ObjectValueProvider(model);
var actual = target.GetValue("MyDouble");
actual.Should()
.Be(model.MyDouble.ToString(CultureInfo.InvariantCulture));
}
public void GetValueTest1()
{
var model = InstanceCreator.CreateInstance <TestModel>();
var target = new ObjectValueProvider(model);
var actual = target.GetValue("MyInt32");
actual.Should()
.Be(model.MyInt32.ToString());
}
public void ApplyTo(T obj, ObjectValueProvider valueProvider)
{
object value;
if (valueProvider.TryGetValue(_property.Property.Name, out value))
{
var nullableValue = (TValue?)value;
_property.Set(obj, nullableValue);
}
}
public object GetObject(ObjectValueProvider valueProvider)
{
var implementation = new TImplementation();
for (int i = 0; i < _converters.Length; i++)
{
_converters[i].ApplyTo(implementation, valueProvider);
}
return(implementation);
}
public void ApplyTo(T obj, ObjectValueProvider valueProvider)
{
ObjectValueProvider propertyProvider;
if (valueProvider.TryGetValue(_property.Property.Name, out propertyProvider))
{
object propertyObj = _converter.GetObject(propertyProvider);
_property.Set(obj, propertyObj);
}
}
public void GetValueTest10()
{
var model = InstanceCreator.CreateInstance <TestModel>();
var target = new ObjectValueProvider(model);
var actual = target.GetValue("SubModel.MyDictionaryStringSub[" + model.SubModel.MyDictionaryStringSub.First()
.Key + "]");
actual.Should()
.Be(model.SubModel.MyDictionaryStringSub[model.SubModel.MyDictionaryStringSub.First()
.Key]);
}
public void GetValueTest6()
{
var model = new TestModel
{
MyListInt = new List <Int32>
{
RandomValueEx.GetRandomInt32(),
RandomValueEx.GetRandomInt32(),
RandomValueEx.GetRandomInt32()
}
};
var target = new ObjectValueProvider(model);
var actual = target.GetValue("MyListInt[0]");
actual.Should()
.Be(model.MyListInt[0]
.ToString());
}
public void ApplyTo(T obj, ObjectValueProvider valueProvider)
{
ArrayValueProvider values;
if (!valueProvider.TryGetValue(_property.Property.Name, out values))
{
return;
}
var elements = new List <TElement>();
for (int i = 0;; i++)
{
TElement element;
if (!values.TryGetValue(i, out element))
{
break;
}
elements.Add(element);
}
_property.Set(obj, elements.ToArray());
}
public Task <ITriggerData> BindAsync(object value, ValueBindingContext context)
{
WebhookTriggerData data = (WebhookTriggerData)value;
var bindingData = new Dictionary <string, object>();
bindingData[AuthName] = GetTokenFromGraphClientAsync(data.client);
JObject raw = data.Payload;
object userObject;
if (_parameter.ParameterType == typeof(string)) //Non-.NET language case
{
userObject = JsonConvert.SerializeObject(raw, Formatting.Indented);
}
else
{
userObject = raw.ToObject(_parameter.ParameterType);
}
IValueProvider valueProvider = new ObjectValueProvider(userObject);
var triggerData = new TriggerData(valueProvider, bindingData);
return(Task.FromResult <ITriggerData>(triggerData));
}
private Task <IValueProvider> Bind(object value)
{
var valueProvider = new ObjectValueProvider(value, _type);
return(Task.FromResult <IValueProvider>(valueProvider));
}
async Task <ITriggerData> ITriggerBinding.BindAsync(object value, ValueBindingContext context)
{
HttpContext requestContext = (HttpContext)value;
Stream inputStream = requestContext.Request.Body;
Type destinationType = this.parameter.ParameterType;
var bindingData = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
object convertedValue;
if (inputStream == null)
{
convertedValue = this.parameter.DefaultValue;
}
else if (destinationType.IsAssignableFrom(inputStream.GetType()))
{
// Give them the request stream directly - no buffering
convertedValue = inputStream;
}
else if (destinationType.IsAssignableFrom(typeof(byte[])))
{
// Copy the stream into a simple byte array with the help of MemoryStream
using (var buffer = new MemoryStream((int?)requestContext.Request.ContentLength ?? 4096))
using (inputStream)
{
await inputStream.CopyToAsync(buffer);
convertedValue = buffer.ToArray();
}
}
else
{
// Binding to JToken or some derivative like JObject or JArray.
// This also works for primitives like int, bool, and string.
JToken jsonValue;
using (var reader = new JsonTextReader(new StreamReader(inputStream)))
{
jsonValue = await JToken.ReadFromAsync(reader, context.CancellationToken);
}
if (destinationType.IsAssignableFrom(jsonValue.GetType()))
{
convertedValue = jsonValue;
}
else if (destinationType == typeof(string) && jsonValue.Type != JTokenType.String)
{
// Special case for out-of-proc workers (like nodejs). The binding type
// appears to always be "string" so we need to do a special conversion.
convertedValue = jsonValue.ToString(Formatting.None);
}
else
{
// At this point, we're probably dealing with a POCO
convertedValue = this.ConvertFromJson(jsonValue, destinationType);
}
}
// Support for basic expression binding
bindingData[this.parameter.Name] = convertedValue;
var valueProvider = new ObjectValueProvider(convertedValue, destinationType);
return(new TriggerData(valueProvider, bindingData)
{
ReturnValueProvider = new HttpContextReturnValueBinder(requestContext, destinationType),
});
}
