Ejemplo n.º 1
0
        public virtual void Bind(IRequestBindingContext bindingContext)
        {
            var bindingSource = bindingContext.BindingSource;

            foreach (var p in bindingContext.Metadata.Parameters)
            {
                if (bindingSource.TryGetValue(p.BindingSourceName, p.BindingPath, out var sourceValue))
                {
                    BindParameter(bindingContext, p, sourceValue);
                }
                else if (p.IsRequired)
                {
                    throw new InvalidOperationException($"{p.BindingPath} property value is missed. TODO mg");
                }
            }
        }
Ejemplo n.º 2
0
        protected virtual void BindParameter(IRequestBindingContext bindingContext, RequestParameterMetadata param, RestValue sourceValue)
        {
            if (param.ParameterKind == RequestParameterKind.Route)
            {
                var segments = Bind(param, sourceValue, (n, v) => new RequestRouteSegment(n, v));
                foreach (var segment in segments)
                {
                    bindingContext.AddRouteSegment(segment);
                }
            }
            else if (param.ParameterKind == RequestParameterKind.Header)
            {
                var headers = Bind(param, sourceValue, (n, v) => new RequestHeader(n, v));
                foreach (var header in headers)
                {
                    bindingContext.AddHeader(header);
                }
            }
            else if (param.ParameterKind == RequestParameterKind.Query)
            {
                var queries = Bind(param, sourceValue, (n, v) => new RequestQuery(n, v));

                if (param.StringFormat != null)                                  //TODO костыль
                {
                    foreach (var query in queries.Where(x => !x.Content.IsNull)) //TODO filter at source level
                    {
                        var value          = (IFormattable)query.Content.Value;
                        var formattedValue = value.ToString(param.StringFormat, bindingContext.CultureInfo);

                        bindingContext.AddQuery(new RequestQuery(query.Name, RestValue.Create(formattedValue)));
                    }
                }
                else
                {
                    foreach (var query in queries.Where(x => !x.Content.IsNull)) //TODO filter at source level
                    {
                        bindingContext.AddQuery(query);
                    }
                }
            }
            else if (param.ParameterKind.In(RequestParameterKind.Body, RequestParameterKind.FormField, RequestParameterKind.FormFile))
            {
                if (bindingContext.BindingSource.TryGetValue(param.BindingSourceName, param.BindingPath, out var contentValue))
                {
                    if (param.ParameterKind == RequestParameterKind.Body)
                    {
                        var contentMediaType = param.MediaType ?? MimeTypes.Application.Json;                               //TODO
                        var contentType      = new ContentType(contentMediaType, DefaultEncodingProvider.Encoding.WebName); //TODO charset

                        bindingContext.Body = new RequestBody(contentValue, contentType);
                    }
                    else if (param.ParameterKind == RequestParameterKind.FormField)
                    {
                        var field = new RequestFormField(param.ParameterName, contentValue, param.MediaType ?? DefaultMediaTypeProvider.MediaType);

                        bindingContext.AddFormField(field);
                    }
                    else if (param.ParameterKind == RequestParameterKind.FormFile)
                    {
                        throw new NotImplementedException();
                        //var file = new RequestFormFile(contentValue, param.ParameterName)
                        //{
                        //    FileName = param.FileName,
                        //};

                        //bindingContext.AddFormField(field);
                    }
                    else
                    {
                        throw new NotImplementedException();
                    }
                }
                else if (param.IsRequired)
                {
                    throw new RestException(RestExceptionKind.Mapping, "req param missed");//TODO msg
                }
            }
            else
            {
                throw new NotImplementedException(param.ParameterKind.ToString()); //TODO msg
            }
            //TODO mark parameter as valid
        }