示例#1
0
        /// <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);
        }
示例#2
0
        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;
        }
示例#3
0
        /// <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&lt;Person&gt;(p =&gt; p.Name, p =&gt; 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);
        }
示例#4
0
        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();
        }
示例#6
0
        /// <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;
        }
示例#12
0
        /// <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;
        }
示例#13
0
        /// <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;
        }
示例#15
0
        /// <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;
        }
示例#16
0
 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),
     };
 }
示例#17
0
        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);
        }
示例#22
0
 /// <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));
 }
示例#23
0
 /// <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));
 }
示例#24
0
        /// <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);
        }
示例#25
0
 /// <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&lt;Person&gt;(p =&gt; p.Name, p =&gt; 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));
        }
示例#27
0
 /// <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));
 }
示例#28
0
 /// <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&lt;Person&gt;(p =&gt; p.Name, p =&gt; 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()));
 }
示例#29
0
        /// <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;
 }
示例#31
0
 /// <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));
 }
示例#32
0
        /// <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);
        }