Method generateResponseInterface

http/jsonapi/generator/generate_handler.go:151–256

(route *route, schema *openapi3.T)

}

func (g *Generator) generateResponseInterface(route *route, schema *openapi3.T) error {
	var methods []jen.Code
	methods = append(methods, jen.Qual("net/http", "ResponseWriter"))

	// sort by key
	keys := make([]string, 0, route.operation.Responses.Len())
	for k := range route.operation.Responses.Map() {
		keys = append(keys, k)
	}
	sort.Stable(sort.StringSlice(keys))

	for _, code := range keys {
		response := route.operation.Responses.Map()[code]

		// don't generate response helpers for things that are handled by the framework
		if generatorResponseBlacklist[code] {
			continue
		}

		// error responses have an error message parameter
		codeNum, err := strconv.Atoi(code)
		if err != nil {
			return fmt.Errorf("failed to parse response code %s: %v", code, err)
		}

		// generate method name
		var methodName string
		if response.Ref != "" {
			methodName = generateMethodName(filepath.Base(response.Ref))
		} else if response.Value.Description != nil {
			methodName = generateMethodName(*response.Value.Description)
		}

		method := jen.Id(methodName)
		if codeNum >= 400 {
			method.Params(jen.Error())

			defer func() { // defer to put methods after type
				// generate the method as function for the implementing type
				g.addGoDoc(methodName, fmt.Sprintf("responds with jsonapi error (HTTP code %d)", codeNum))
				g.goSource.Func().Params(jen.Id("w").Op("*").Id(route.responseTypeImpl)).
					Id(methodName).Params(jen.Id("err").Error()).Block(
					jen.Qual(pkgJSONAPIRuntime, "WriteError").Call(
						jen.Id("w"),
						jen.Lit(codeNum),
						jen.Id("err"),
					),
				)
			}()
		} else if mt := response.Value.Content.Get(jsonapiContent); mt != nil {
			typeReference, err := g.generateTypeReference(route.serviceFunc+methodName,
				mt.Schema, false)
			if err != nil {
				return err
			}
			method.Params(typeReference)

			defer func() { // defer to put methods after type