/// <summary>
/// Bind the incoming request to a model and validate
/// </summary>
/// <typeparam name="TModel">Model type</typeparam>
/// <param name="module">Current module</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <param name="blacklistedProperties">Property names to blacklist from binding</param>
/// <returns>Bound model instance</returns>
/// <remarks><see cref="ModelValidationResult"/> is stored in NancyModule.ModelValidationResult and NancyContext.ModelValidationResult.</remarks>
public static TModel BindAndValidate <TModel>(this INancyModule module, BindingConfig configuration, params string[] blacklistedProperties)
{
var model = module.Bind <TModel>(configuration, blacklistedProperties);
module.Validate(model);
return(model);
}
public object Bind(NancyContext context, Type modelType, object instance, BindingConfig configuration, params string[] blackList)
{
IDictionary<string, object> data = GetDataFields(context);
DynamicDictionary model = DynamicDictionary.Create(data);
return model;
}
/// <summary>
/// Bind the incoming request to a model and validate
/// </summary>
/// <typeparam name="TModel">Model type</typeparam>
/// <param name="module">Current module</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <param name="blacklistedProperties">Expressions that tell which property should be ignored</param>
/// <example>this.Bind<Person>(p => p.Name, p => p.Age)</example>
/// <returns>Bound model instance</returns>
/// <remarks><see cref="ModelValidationResult"/> is stored in NancyModule.ModelValidationResult and NancyContext.ModelValidationResult.</remarks>
public static TModel BindAndValidate <TModel>(this INancyModule module, BindingConfig configuration, params Expression <Func <TModel, object> >[] blacklistedProperties)
{
var model = module.Bind <TModel>(configuration, blacklistedProperties.ParseBlacklistedPropertiesExpressionTree());
module.Validate(model);
return(model);
}
public Servers()
{
InitializeGet(Helper.Servers, "servers");
InitializeGetAll(Helper.Servers, "servers");
InitializeEnable(Helper.Servers, "servers");
InitializeDelete(Helper.Servers, "servers");
Put["/servers", true] = async(_, ct) =>
{
Request.ServerAdd request;
try
{
var config = new BindingConfig { BodyOnly = true, IgnoreErrors = false };
request = this.Bind<Request.ServerAdd>(config);
request.ApiKey = Guid.Parse(Context.CurrentUser.UserName);
var results = Validate(request);
if (results.Count > 0)
{
return CreateErrorResponseAndUpdateApiKey((from result in results select result.ErrorMessage).Implode(", "));
}
}
catch (Exception ex)
{
return CreateErrorResponseAndUpdateApiKey(ex.Message);
}
return ExecuteRequest(request);
};
}
public void Should_allow_overwrite_on_new_instance()
{
// Given
// When
var instance = new BindingConfig();
// Then
instance.Overwrite.ShouldBeTrue();
}
/// <summary>
/// Bind to the given model type
/// </summary>
/// <param name="context">Current context</param>
/// <param name="modelType">Model type to bind to</param>
/// <param name="instance">Optional existing instance</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <param name="blackList">Blacklisted property names</param>
/// <returns>Bound model</returns>
public object Bind(NancyContext context, Type modelType, object instance, BindingConfig configuration, params string[] blackList)
{
var customer = (instance as Customer) ?? new Customer();
customer.Name = customer.Name ?? context.Request.Form["Name"];
customer.RenewalDate = customer.RenewalDate == default(DateTime) ? context.Request.Form["RenewalDate"] : customer.RenewalDate;
return customer;
}
public BindingContextForTests(Type destinationType, Type genericType)
{
DestinationType = destinationType;
GenericType = genericType;
Configuration = new BindingConfig();
ValidModelProperties = GetProperties(destinationType, genericType);
TypeConverters = GetTypeConverters();
}
public object Bind(NancyContext context, Type modelType, object instance, BindingConfig configuration, params string[] blackListedProperties)
{
var data =
GetDataFields(context, blackListedProperties);
var model =
DynamicDictionary.Create(data);
return model;
}
public object Bind(NancyContext context, Type modelType, object instance, BindingConfig configuration, params string[] blackList)
{
var body = Encoding.UTF8.GetString(
context.Request.Body.ReadBytes((int)context.Request.Body.Length)
);
var data = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>(
body
);
return data;
}
public object Bind(NancyContext context, Type modelType, object instance, BindingConfig configuration, params string[] blackList)
{
var fileUploadRequest = (instance as FileUploadRequest) ?? new FileUploadRequest();
var form = context.Request.Form;
fileUploadRequest.Tags = GetTags(form["tags"]);
fileUploadRequest.Title = form["title"];
fileUploadRequest.Description = form["description"];
fileUploadRequest.File = GetFileByKey(context, "file");
return fileUploadRequest;
}
/// <summary>
/// Extracts data from the Nancy Request Context and binds it to a DynamicDictionary object.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="modelType">Type of the model.</param>
/// <param name="instance">The instance.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="blackListedProperties">The black listed properties.</param>
/// <returns></returns>
public object Bind(NancyContext context, Type modelType, object instance, BindingConfig configuration, params string[] blackListedProperties)
{
object model = null;
if (modelType == typeof(DynamicDictionary))
{
var data = GetDataFields(context, blackListedProperties);
model = DynamicDictionary.Create(data);
}
else if (modelType == typeof(IList<PatchOperationDto>))
{
model = ParsePatchOperationsList(context.Request);
}
return model;
}
/// <summary>
/// Bind to the given model type
/// </summary>
/// <param name="context">Current context</param>
/// <param name="modelType">Model type to bind to</param>
/// <param name="instance">Optional existing instance</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <param name="blackList">Blacklisted property names</param>
/// <returns>Bound model</returns>
public object Bind(NancyContext context, Type modelType, object instance, BindingConfig configuration, params string[] blackList)
{
var bindingContext =
this.CreateBindingContext(context, modelType, instance, configuration, blackList);
var bodyDeserializedModel = this.DeserializeRequestBody(bindingContext);
if (bodyDeserializedModel != null)
{
UpdateModelWithDeserializedModel(bodyDeserializedModel, bindingContext);
}
if (!configuration.BodyOnly)
{
var bindingExceptions = new List<PropertyBindingException>();
foreach (var modelProperty in bindingContext.ValidModelProperties)
{
var existingValue =
modelProperty.GetValue(bindingContext.Model, null);
var stringValue = GetValue(modelProperty.Name, bindingContext);
if (!String.IsNullOrEmpty(stringValue) && (IsDefaultValue(existingValue, modelProperty.PropertyType) || bindingContext.Configuration.Overwrite))
{
try
{
BindProperty(modelProperty, stringValue, bindingContext);
}
catch (PropertyBindingException ex)
{
bindingExceptions.Add(ex);
}
}
}
if (bindingExceptions.Any())
{
throw new ModelBindingException(modelType, bindingExceptions);
}
}
return bindingContext.Model;
}
/// <summary>
/// Bind to the given model type
/// </summary>
/// <param name="context">Current context</param>
/// <param name="modelType">Model type to bind to</param>
/// <param name="instance">Optional existing instance</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <param name="blackList">Blacklisted property names</param>
/// <returns>Bound model</returns>
public object Bind(NancyContext context, Type modelType, object instance, BindingConfig configuration, params string[] blackList)
{
var bindingContext =
this.CreateBindingContext(context, modelType, instance, configuration, blackList);
var bodyDeserializedModel = this.DeserializeRequestBody(bindingContext);
if (bodyDeserializedModel != null)
{
UpdateModelWithDeserializedModel(bodyDeserializedModel, bindingContext);
}
if (!configuration.BodyOnly)
{
var bindingExceptions = new List <PropertyBindingException>();
foreach (var modelProperty in bindingContext.ValidModelProperties)
{
var existingValue =
modelProperty.GetValue(bindingContext.Model, null);
var stringValue = GetValue(modelProperty.Name, bindingContext);
if (!String.IsNullOrEmpty(stringValue) && (IsDefaultValue(existingValue, modelProperty.PropertyType) || bindingContext.Configuration.Overwrite))
{
try
{
BindProperty(modelProperty, stringValue, bindingContext);
}
catch (PropertyBindingException ex)
{
bindingExceptions.Add(ex);
}
}
}
if (bindingExceptions.Any())
{
throw new ModelBindingException(modelType, bindingExceptions);
}
}
return(bindingContext.Model);
}
/// <summary>
/// Initializes a new instance of the <see cref="DynamicModelBinderAdapter"/> class.
/// </summary>
/// <param name="locator">Model binder locator</param>
/// <param name="context">Nancy context</param>
/// <param name="instance">Optional existing instance, or null</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <param name="blacklistedProperties">Blacklisted property names</param>
public DynamicModelBinderAdapter(IModelBinderLocator locator, NancyContext context, object instance, BindingConfig configuration, params string[] blacklistedProperties)
{
if (locator == null)
{
throw new ArgumentNullException("locator");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
this.locator = locator;
this.context = context;
this.instance = instance;
this.configuration = configuration;
this.blacklistedProperties = blacklistedProperties;
}
/// <summary>
/// Initializes a new instance of the <see cref="DynamicModelBinderAdapter"/> class.
/// </summary>
/// <param name="locator">Model binder locator</param>
/// <param name="context">Nancy context</param>
/// <param name="instance">Optional existing instance, or null</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <param name="blacklistedProperties">Blacklisted property names</param>
public DynamicModelBinderAdapter(IModelBinderLocator locator, NancyContext context, object instance, BindingConfig configuration, params string[] blacklistedProperties)
{
if (locator == null)
{
throw new ArgumentNullException("locator");
}
if (context == null)
{
throw new ArgumentNullException("context");
}
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
this.locator = locator;
this.context = context;
this.instance = instance;
this.configuration = configuration;
this.blacklistedProperties = blacklistedProperties;
}
private BindingContext CreateBindingContext(NancyContext context, Type modelType, object instance, BindingConfig configuration, IEnumerable<string> blackList, Type genericType)
{
return new BindingContext
{
Configuration = configuration,
Context = context,
DestinationType = modelType,
Model = CreateModel(modelType, genericType, instance),
ValidModelProperties = GetProperties(modelType, genericType, blackList),
RequestData = this.GetDataFields(context),
GenericType = genericType,
TypeConverters = this.typeConverters.Concat(this.defaults.DefaultTypeConverters),
};
}
public ServiceModule(ServiceManager serviceManager)
{
// Find all service methods having a ServiceGetContractAttribute attached to it.
var bindQuery = from service in serviceManager.Services
from method in service.GetType().GetMethods()
from attribute in method.GetCustomAttributes(true)
where attribute is ServiceBase.ServiceGetContractAttribute
select new { service, method, attribute };
foreach (var bindData in bindQuery)
{
var service = bindData.service;
var method = bindData.method;
var attribute = bindData.attribute;
var contract = attribute as ServiceBase.ServiceGetContractAttribute;
if (contract == null)
continue;
bool isPut = contract is ServiceBase.ServicePutContractAttribute;
var mapper = new ContractMapper("/" + service.Name + "/" + contract.uri, method);
string uri = mapper.GetMappedUri();
Func<dynamic, dynamic> lambda = parameters =>
{
var arguments = new List<object>();
mapper.MapArguments(parameters, Request.Query, arguments);
if (mapper.BindBody && mapper.DynamicBody)
{
// Bind manually for now until I've fixed the dynamic type.
// Attempt to deserialize body from Json
Nancy.DynamicDictionary body = null;
if (Request.Body.Length > 0)
{
var buffer = new byte[Request.Body.Length];
Request.Body.Position = 0;
Request.Body.Read(buffer, 0, (int)Request.Body.Length);
string bodyStr = Encoding.Default.GetString(buffer);
Log.Debug("Got body data:\n{0}", bodyStr);
var serializer = new Nancy.Json.JavaScriptSerializer();
try
{
var bodyJson = serializer.DeserializeObject(bodyStr) as System.Collections.Generic.Dictionary<string, object>;
if (bodyJson != null)
body = Nancy.DynamicDictionary.Create(bodyJson);
}
catch (System.ArgumentException)
{
// Just eat it.
Log.Warning("Got request with invalid json body for url: " + Request.Url);
return null;
}
}
arguments.Add(body);
}
else if (mapper.BindBody)
{
// Bind specific type.
var config = new BindingConfig();
config.BodyOnly = true;
config.IgnoreErrors = false;
// The Bind<> method exists on the ModuleExtension rather than the NancyModule.
var extensionMethods = typeof(ModuleExtensions).GetMethods();
var methodList = new List<MethodInfo>(extensionMethods);
// Get correct generic bind method
var bindMethod = methodList.Find(x => x.Name == "Bind" && x.GetParameters().Length == 1 && x.IsGenericMethod == true);
var genericMethod = bindMethod.MakeGenericMethod(mapper.BodyType);
// Bind our object.
var boundBody = genericMethod.Invoke(null, new object[] { this });
arguments.Add(boundBody);
}
try
{
object result = method.Invoke(service, arguments.ToArray());
return Response.AsJson(result);
}
catch (TargetInvocationException e)
{
Log.Error(
"Invocation exception of uri: " + uri + "\n"
+ "Exception: " + e.Message + "\n"
+ "Callstack:" + e.StackTrace + "\n"
+ "Inner: " + e.InnerException.Message + "\n"
+ "Callstack: " + e.InnerException.StackTrace);
// TODO - A better way to unwrap this? Just throwing inner exception will cause an ObjectDisposedException
throw new Exception(e.InnerException.Message);
}
};
if (isPut)
{
//Log.Debug("Adding PUT binding for {0}", uri);
Put[uri] = lambda;
Post[uri] = lambda;
}
else
{
//Log.Debug("Adding GET binding for {0}", uri);
Get[uri] = lambda;
}
}
}
public object Bind(NancyContext context, Type modelType, object instance, BindingConfig configuration, params string[] blackList)
{
StreamReader reader = new StreamReader(context.Request.Body);
return reader.ReadToEnd();
}
/// <summary>
/// Bind to the given model type
/// </summary>
/// <param name="context">Current context</param>
/// <param name="modelType">Model type to bind to</param>
/// <param name="instance">Optional existing instance</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <param name="blackList">Blacklisted binding property names</param>
/// <returns>Bound model</returns>
public object Bind(NancyContext context, Type modelType, object instance, BindingConfig configuration, params string[] blackList)
{
Type genericType = null;
if (modelType.IsArray() || modelType.IsCollection() || modelType.IsEnumerable())
{
//make sure it has a generic type
if (modelType.GetTypeInfo().IsGenericType)
{
genericType = modelType.GetGenericArguments().FirstOrDefault();
}
else
{
var ienumerable =
modelType.GetInterfaces().Where(i => i.GetTypeInfo().IsGenericType).FirstOrDefault(
i => i.GetGenericTypeDefinition() == typeof(IEnumerable <>));
genericType = ienumerable == null ? null : ienumerable.GetGenericArguments().FirstOrDefault();
}
if (genericType == null)
{
throw new ArgumentException("When modelType is an enumerable it must specify the type.", "modelType");
}
}
var bindingContext =
this.CreateBindingContext(context, modelType, instance, configuration, blackList, genericType);
try
{
var bodyDeserializedModel = this.DeserializeRequestBody(bindingContext);
if (bodyDeserializedModel != null)
{
UpdateModelWithDeserializedModel(bodyDeserializedModel, bindingContext);
}
}
catch (Exception exception)
{
if (!bindingContext.Configuration.IgnoreErrors)
{
throw new ModelBindingException(modelType, innerException: exception);
}
}
var bindingExceptions = new List <PropertyBindingException>();
if (!bindingContext.Configuration.BodyOnly)
{
if (bindingContext.DestinationType.IsCollection() || bindingContext.DestinationType.IsArray() || bindingContext.DestinationType.IsEnumerable())
{
var loopCount = this.GetBindingListInstanceCount(context);
var model = (IList)bindingContext.Model;
for (var i = 0; i < loopCount; i++)
{
object genericinstance;
if (model.Count > i)
{
genericinstance = model[i];
}
else
{
genericinstance = bindingContext.GenericType.CreateInstance();
model.Add(genericinstance);
}
foreach (var modelProperty in bindingContext.ValidModelBindingMembers)
{
var existingCollectionValue = modelProperty.GetValue(genericinstance);
var collectionStringValue = GetValue(modelProperty.Name, bindingContext, i);
if (this.BindingValueIsValid(collectionStringValue, existingCollectionValue, modelProperty,
bindingContext))
{
try
{
BindValue(modelProperty, collectionStringValue, bindingContext, genericinstance);
}
catch (PropertyBindingException ex)
{
bindingExceptions.Add(ex);
}
}
}
}
}
else
{
foreach (var modelProperty in bindingContext.ValidModelBindingMembers)
{
var existingValue = modelProperty.GetValue(bindingContext.Model);
var stringValue = GetValue(modelProperty.Name, bindingContext);
if (this.BindingValueIsValid(stringValue, existingValue, modelProperty, bindingContext))
{
try
{
BindValue(modelProperty, stringValue, bindingContext);
}
catch (PropertyBindingException ex)
{
bindingExceptions.Add(ex);
}
}
}
}
if (bindingExceptions.Any() && !bindingContext.Configuration.IgnoreErrors)
{
throw new ModelBindingException(modelType, bindingExceptions);
}
}
if (modelType.IsArray())
{
var generictoArrayMethod = ToArrayMethodInfo.MakeGenericMethod(new[] { genericType });
return(generictoArrayMethod.Invoke(null, new[] { bindingContext.Model }));
}
return(bindingContext.Model);
}
private BindingContext CreateBindingContext(NancyContext context, Type modelType, object instance, BindingConfig configuration, IEnumerable <string> blackList, Type genericType)
{
return(new BindingContext
{
Configuration = configuration,
Context = context,
DestinationType = modelType,
Model = CreateModel(modelType, genericType, instance),
ValidModelBindingMembers = GetBindingMembers(modelType, genericType, blackList).ToList(),
RequestData = this.GetDataFields(context),
GenericType = genericType,
TypeConverters = this.typeConverters.Concat(this.defaults.DefaultTypeConverters),
});
}
public void Should_set_remaining_properties_when_one_fails_and_ignore_error_is_enabled()
{
// Given
var binder = this.GetBinder(typeConverters: new[] { new FallbackConverter() });
var context = new NancyContext { Request = new FakeRequest("GET", "/") };
context.Request.Form["IntProperty"] = "badint";
context.Request.Form["AnotherIntProperty"] = 10;
var config = new BindingConfig { IgnoreErrors = true };
// When
var model = binder.Bind(context, typeof(TestModel), null, config) as TestModel;
// Then
model.AnotherIntProperty.ShouldEqual(10);
}
/// <summary>
/// Bind the incoming request to an existing instance
/// </summary>
/// <typeparam name="TModel">Model type</typeparam>
/// <param name="module">Current module</param>
/// <param name="instance">The class instance to bind properties to</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
public static TModel BindTo <TModel>(this INancyModule module, TModel instance, BindingConfig configuration)
{
return(module.BindTo(instance, configuration, NoBlacklistedProperties));
}
/// <summary>
/// Bind the incoming request to a model
/// </summary>
/// <param name="module">Current module</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <param name="blacklistedProperties">Property names to blacklist from binding</param>
/// <returns>Model adapter - cast to a model type to bind it</returns>
public static dynamic Bind(this INancyModule module, BindingConfig configuration, params string[] blacklistedProperties)
{
return(new DynamicModelBinderAdapter(module.ModelBinderLocator, module.Context, null, configuration, blacklistedProperties));
}
/// <summary>
/// Bind the incoming request to an existing instance
/// </summary>
/// <typeparam name="TModel">Model type</typeparam>
/// <param name="module">Current module</param>
/// <param name="instance">The class instance to bind properties to</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <param name="blacklistedProperties">Property names to blacklist from binding</param>
public static TModel BindTo <TModel>(this INancyModule module, TModel instance, BindingConfig configuration, params string[] blacklistedProperties)
{
dynamic adapter =
new DynamicModelBinderAdapter(module.ModelBinderLocator, module.Context, instance, configuration, blacklistedProperties);
return(adapter);
}
/// <summary>
/// Bind the incoming request to an existing instance
/// </summary>
/// <typeparam name="TModel">Model type</typeparam>
/// <param name="module">Current module</param>
/// <param name="instance">The class instance to bind properties to</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <param name="blacklistedProperties">Expressions that tell which property should be ignored</param>
/// <example>this.Bind<Person>(p => p.Name, p => p.Age)</example>
public static TModel BindTo <TModel>(this INancyModule module, TModel instance, BindingConfig configuration, params Expression <Func <TModel, object> >[] blacklistedProperties)
{
return(module.BindTo <TModel>(instance, configuration, blacklistedProperties.ParseBlacklistedPropertiesExpressionTree()));
}
public void Should_not_throw_ModelBindingException_if_convertion_of_property_fails_and_ignore_error_is_true()
{
// Given
var binder = this.GetBinder(typeConverters: new[] { new FallbackConverter() });
var context = new NancyContext { Request = new FakeRequest("GET", "/") };
context.Request.Form["IntProperty"] = "badint";
context.Request.Form["AnotherIntProperty"] = "morebad";
var config = new BindingConfig {IgnoreErrors = true};
// When
// Then
Assert.DoesNotThrow(() => binder.Bind(context, typeof(TestModel), null, config));
}
/// <summary>
/// Bind the incoming request to a model
/// </summary>
/// <typeparam name="TModel">Model type</typeparam>
/// <param name="module">Current module</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <returns>Bound model instance</returns>
public static TModel Bind <TModel>(this INancyModule module, BindingConfig configuration)
{
return(module.Bind(configuration));
}
/// <summary>
/// Bind the incoming request to a model
/// </summary>
/// <typeparam name="TModel">Model type</typeparam>
/// <param name="module">Current module</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <param name="blacklistedProperty">Expressions that tell which property should be ignored</param>
/// <example>this.Bind<Person>(p => p.Name, p => p.Age)</example>
/// <returns>Bound model instance</returns>
public static TModel Bind <TModel>(this INancyModule module, BindingConfig configuration, Expression <Func <TModel, object> > blacklistedProperty)
{
return(module.Bind(configuration, new [] { blacklistedProperty }.ParseBlacklistedPropertiesExpressionTree()));
}
/// <summary>
/// Bind to the given model type
/// </summary>
/// <param name="context">Current context</param>
/// <param name="modelType">Model type to bind to</param>
/// <param name="instance">Optional existing instance</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <param name="blackList">Blacklisted property names</param>
/// <returns>Bound model</returns>
public object Bind(NancyContext context, Type modelType, object instance, BindingConfig configuration, params string[] blackList)
{
Type genericType = null;
if (modelType.IsArray() || modelType.IsCollection() || modelType.IsEnumerable())
{
//make sure it has a generic type
if (modelType.IsGenericType())
{
genericType = modelType.GetGenericArguments().FirstOrDefault();
}
else
{
var ienumerable =
modelType.GetInterfaces().Where(i => i.IsGenericType()).FirstOrDefault(
i => i.GetGenericTypeDefinition() == typeof(IEnumerable<>));
genericType = ienumerable == null ? null : ienumerable.GetGenericArguments().FirstOrDefault();
}
if (genericType == null)
{
throw new ArgumentException("when modeltype is an enumerble it must specify the type", "modelType");
}
}
var bindingContext =
this.CreateBindingContext(context, modelType, instance, configuration, blackList, genericType);
var bodyDeserializedModel = this.DeserializeRequestBody(bindingContext);
if (bodyDeserializedModel != null)
{
UpdateModelWithDeserializedModel(bodyDeserializedModel, bindingContext);
}
var bindingExceptions = new List<PropertyBindingException>();
if (!bindingContext.Configuration.BodyOnly)
{
if (bindingContext.DestinationType.IsCollection() || bindingContext.DestinationType.IsArray() ||
bindingContext.DestinationType.IsEnumerable())
{
var loopCount = GetBindingListInstanceCount(context);
var model = (IList)bindingContext.Model;
for (var i = 0; i < loopCount; i++)
{
object genericinstance;
if (model.Count > i)
{
genericinstance = model[i];
}
else
{
genericinstance = Activator.CreateInstance(bindingContext.GenericType);
model.Add(genericinstance);
}
foreach (var modelProperty in bindingContext.ValidModelProperties)
{
var existingCollectionValue = modelProperty.GetValue(genericinstance, null);
var collectionStringValue = GetValue(modelProperty.Name, bindingContext, i);
if (BindingValueIsValid(collectionStringValue, existingCollectionValue, modelProperty,
bindingContext))
{
try
{
BindProperty(modelProperty, collectionStringValue, bindingContext, genericinstance);
}
catch (PropertyBindingException ex)
{
bindingExceptions.Add(ex);
}
}
}
}
}
else
{
foreach (var modelProperty in bindingContext.ValidModelProperties)
{
var existingValue = modelProperty.GetValue(bindingContext.Model, null);
var stringValue = GetValue(modelProperty.Name, bindingContext);
if (BindingValueIsValid(stringValue, existingValue, modelProperty, bindingContext))
{
try
{
BindProperty(modelProperty, stringValue, bindingContext);
}
catch (PropertyBindingException ex)
{
bindingExceptions.Add(ex);
}
}
}
}
if (bindingExceptions.Any())
{
throw new ModelBindingException(modelType, bindingExceptions);
}
}
if (modelType.IsArray())
{
var generictoArrayMethod = toArrayMethodInfo.MakeGenericMethod(new[] { genericType });
return generictoArrayMethod.Invoke(null, new[] { bindingContext.Model });
}
return bindingContext.Model;
}
public object Bind(NancyContext context, Type modelType, object instance, BindingConfig configuration, params string[] blackList)
{
return new Concrete() as IAmAnInterface;
}
/// <summary>
/// Bind the incoming request to a model
/// </summary>
/// <typeparam name="TModel">Model type</typeparam>
/// <param name="module">Current module</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <param name="blacklistedProperties">Property names to blacklist from binding</param>
/// <returns>Bound model instance</returns>
public static TModel Bind <TModel>(this INancyModule module, BindingConfig configuration, params string[] blacklistedProperties)
{
return(module.Bind(configuration, blacklistedProperties));
}
/// <summary>
/// Bind the incoming request to an existing instance and validate
/// </summary>
/// <typeparam name="TModel">Model type</typeparam>
/// <param name="module">Current module</param>
/// <param name="instance">The class instance to bind properties to</param>
/// <param name="configuration">The <see cref="BindingConfig"/> that should be applied during binding.</param>
/// <remarks><see cref="ModelValidationResult"/> is stored in NancyModule.ModelValidationResult and NancyContext.ModelValidationResult.</remarks>
public static TModel BindToAndValidate <TModel>(this INancyModule module, TModel instance, BindingConfig configuration)
{
var model = module.BindTo(instance, configuration, NoBlacklistedProperties);
module.Validate(model);
return(model);
}