func contentType(req *http.Request) int { str := httputil.NegotiateContentType(req, []string{"text/plain", "application/json"}, "text/plain") if str == "application/json" { return ContentJSON } else { return ContentText } }
func TestNegotiateContentType(t *testing.T) { for _, tt := range negotiateContentTypeTests { r := &http.Request{Header: http.Header{"Accept": {tt.s}}} actual := httputil.NegotiateContentType(r, tt.offers, tt.defaultOffer) if actual != tt.expect { t.Errorf("NegotiateContentType(%q, %#v, %q)=%q, want %q", tt.s, tt.offers, tt.defaultOffer, actual, tt.expect) } } }
// ResponseFormat negotiates the response content type func (c *Context) ResponseFormat(r *http.Request, offers []string) string { if v, ok := context.GetOk(r, ctxResponseFormat); ok { if val, ok := v.(string); ok { return val } } format := httputil.NegotiateContentType(r, offers, "") if format != "" { context.Set(r, ctxResponseFormat, format) } return format }
// EncodeResponse uses registered Encoders to marshal the response body based on the request // `Accept` header and writes it to the http.ResponseWriter func (app *Application) EncodeResponse(ctx *Context, v interface{}) error { contentType := httputil.NegotiateContentType(ctx.Request(), app.encodableContentTypes, "*/*") p := app.encoderPools[contentType] // the encoderPool will handle whether or not a pool is actually in use encoder := p.Get(ctx) if err := encoder.Encode(v); err != nil { // TODO: log out error details return err } p.Put(encoder) return nil }
// TypeNegotiator returns a content type negotiation handler. // // The method takes a list of response MIME types that are supported by the application. // The negotiator will determine the best response MIME type to use by checking the "Accept" HTTP header. // If no match is found, the first MIME type will be used. // // The negotiator will set the "Content-Type" response header as the chosen MIME type. It will call routing.Context.SetDataWriter() // to set the appropriate data writer that can write data in the negotiated format. // // If you do not specify any supported MIME types, the negotiator will use "text/html" as the response MIME type. func TypeNegotiator(formats ...string) routing.Handler { if len(formats) == 0 { formats = []string{HTML} } for _, format := range formats { if _, ok := DataWriters[format]; !ok { panic(format + " is not supported") } } return func(c *routing.Context) error { format := httputil.NegotiateContentType(c.Request, formats, formats[0]) DataWriters[format].SetHeader(c.Response) c.SetDataWriter(DataWriters[format]) return nil } }
func contentType(req *http.Request) int { str := httputil.NegotiateContentType(req, []string{ "text/plain", "application/json", "application/yaml", "application/x-yaml", "text/yaml", "text/x-yaml", }, "text/plain") if strings.Contains(str, "json") { return ContentJSON } else if strings.Contains(str, "yaml") { return ContentYAML } else { return ContentText } }
func selectContentMarshaler(r *http.Request, marshalers map[string]ContentMarshaler) (marshaler ContentMarshaler, contentType string) { if _, found := r.Header["Accept"]; found { var contentTypes []string for ct := range marshalers { contentTypes = append(contentTypes, ct) } contentType = httputil.NegotiateContentType(r, contentTypes, defaultContentTypHeader) marshaler = marshalers[contentType] } else if contentTypes, found := r.Header["Content-Type"]; found { contentType = contentTypes[0] marshaler = marshalers[contentType] } if marshaler == nil { contentType = defaultContentTypHeader marshaler = JSONContentMarshaler{} } return }
// BindValidRequest binds a params object to a request but only when the request is valid // if the request is not valid an error will be returned func (c *Context) BindValidRequest(request *http.Request, route *MatchedRoute, binder RequestBinder) error { var res []error // check and validate content type, select consumer if httpkit.CanHaveBody(request.Method) { ct, _, err := httpkit.ContentType(request.Header) if err != nil { res = append(res, err) } else { if err := validateContentType(route.Consumes, ct); err != nil { res = append(res, err) } route.Consumer = route.Consumers[ct] } } // check and validate the response format if len(res) == 0 { if str := httputil.NegotiateContentType(request, route.Produces, ""); str == "" { res = append(res, errors.InvalidResponseFormat(request.Header.Get(httpkit.HeaderAccept), route.Produces)) } } // now bind the request with the provided binder // it's assumed the binder will also validate the request and return an error if the // request is invalid if binder != nil && len(res) == 0 { if err := binder.BindRequest(request, route); err != nil { res = append(res, err) } } if len(res) > 0 { return errors.CompositeValidationError(res...) } return nil }
func templateExt(req *http.Request) string { if httputil.NegotiateContentType(req, []string{"text/html", "text/plain"}, "text/html") == "text/plain" { return ".txt" } return ".html" }