func (sg *schemaGenContext) NewSliceBranch(schema *spec.Schema) *schemaGenContext {
if Debug {
log.Printf("new slice branch %s (model: %s)", sg.Name, sg.TypeResolver.ModelName)
}
pg := sg.shallowClone()
indexVar := pg.IndexVar
if pg.Path == "" {
pg.Path = "strconv.Itoa(" + indexVar + ")"
} else {
pg.Path = pg.Path + "+ \".\" + strconv.Itoa(" + indexVar + ")"
}
// check who is parent, if it's a base type then rewrite the value expression
var rewriteValueExpr bool
if sg.Discrimination != nil && sg.Discrimination.Discriminators != nil {
_, rewriteValueExpr = sg.Discrimination.Discriminators["#/definitions/"+sg.TypeResolver.ModelName]
if pg.IndexVar == "i" && rewriteValueExpr {
pg.ValueExpr = sg.Receiver + "." + swag.ToJSONName(sg.GenSchema.Name) + "Field"
}
}
pg.IndexVar = indexVar + "i"
pg.ValueExpr = pg.ValueExpr + "[" + indexVar + "]"
pg.Schema = *schema
pg.Required = false
if sg.IsVirtual {
resolver := newTypeResolver(sg.TypeResolver.ModelsPackage, sg.TypeResolver.Doc)
resolver.ModelName = sg.TypeResolver.ModelName
pg.TypeResolver = resolver
}
// when this is an anonymous complex object, this needs to become a ref
return pg
}
func (t *Repository) addFile(name, data string, allowOverride bool) error {
fileName := name
name = swag.ToJSONName(strings.TrimSuffix(name, ".gotmpl"))
templ, err := template.New(name).Funcs(t.funcs).Parse(data)
if err != nil {
return err
}
// check if any protected templates are defined
if !allowOverride {
for _, template := range templ.Templates() {
if protectedTemplates[template.Name()] {
return fmt.Errorf("Cannot overwrite protected template %s", template.Name())
}
}
}
// Add each defined tempalte into the cache
for _, template := range templ.Templates() {
t.files[template.Name()] = fileName
t.templates[template.Name()] = template.Lookup(template.Name())
}
return nil
}
func (isn *inlineSchemaNamer) Name(key string, schema *swspec.Schema, aschema *AnalyzedSchema) error {
if swspec.Debug {
log.Printf("naming inlined schema at %s", key)
}
parts := keyParts(key)
for _, name := range namesFromKey(parts, aschema, isn.Operations) {
if name != "" {
// create unique name
newName := uniqifyName(isn.Spec.Definitions, swag.ToJSONName(name))
// clone schema
sch, err := cloneSchema(schema)
if err != nil {
return err
}
// replace values on schema
if err := rewriteSchemaToRef(isn.Spec, key, swspec.MustCreateRef("#/definitions/"+newName)); err != nil {
return fmt.Errorf("name inlined schema: %v", err)
}
sch.AddExtension("x-go-gen-location", genLocation(parts))
// fmt.Printf("{\n %q,\n \"\",\n spec.MustCreateRef(%q),\n \"\",\n},\n", key, "#/definitions/"+newName)
// save cloned schema to definitions
saveSchema(isn.Spec, newName, sch)
}
}
return nil
}
func nameFromRef(ref swspec.Ref) string {
u := ref.GetURL()
if u.Fragment != "" {
return swag.ToJSONName(path.Base(u.Fragment))
}
if u.Path != "" {
bn := path.Base(u.Path)
if bn != "" && bn != "/" {
ext := path.Ext(bn)
if ext != "" {
return swag.ToJSONName(bn[:len(bn)-len(ext)])
}
return swag.ToJSONName(bn)
}
}
return swag.ToJSONName(strings.Replace(u.Host, ".", " ", -1))
}
func (a *appGenerator) makeConsumes() (consumes []GenSerGroup, consumesJSON bool) {
for _, cons := range a.Analyzed.RequiredConsumes() {
cn, ok := mediaTypeName(cons)
if !ok {
continue
}
nm := swag.ToJSONName(cn)
if nm == "json" {
consumesJSON = true
}
if ser, ok := getSerializer(consumes, cn); ok {
ser.AllSerializers = append(ser.AllSerializers, GenSerializer{
AppName: ser.AppName,
ReceiverName: ser.ReceiverName,
Name: ser.Name,
MediaType: cons,
Implementation: knownConsumers[nm],
})
continue
}
ser := GenSerializer{
AppName: a.Name,
ReceiverName: a.Receiver,
Name: nm,
MediaType: cons,
Implementation: knownConsumers[nm],
}
consumes = append(consumes, GenSerGroup{
AppName: ser.AppName,
ReceiverName: ser.ReceiverName,
Name: ser.Name,
MediaType: cons,
AllSerializers: []GenSerializer{ser},
Implementation: ser.Implementation,
})
}
if len(consumes) == 0 {
consumes = append(consumes, GenSerGroup{
AppName: a.Name,
ReceiverName: a.Receiver,
Name: "json",
MediaType: runtime.JSONMime,
AllSerializers: []GenSerializer{GenSerializer{
AppName: a.Name,
ReceiverName: a.Receiver,
Name: "json",
MediaType: runtime.JSONMime,
Implementation: knownConsumers["json"],
}},
Implementation: knownConsumers["json"],
})
consumesJSON = true
}
return
}
func (a *appGenerator) makeProduces() (produces []GenSerGroup, producesJSON bool) {
for _, prod := range a.Analyzed.RequiredProduces() {
pn, ok := mediaTypeName(prod)
if !ok {
continue
}
nm := swag.ToJSONName(pn)
if nm == "json" {
producesJSON = true
}
if ser, ok := getSerializer(produces, pn); ok {
ser.AllSerializers = append(ser.AllSerializers, GenSerializer{
AppName: ser.AppName,
ReceiverName: ser.ReceiverName,
Name: ser.Name,
MediaType: prod,
Implementation: knownProducers[nm],
})
continue
}
ser := GenSerializer{
AppName: a.Name,
ReceiverName: a.Receiver,
Name: nm,
MediaType: prod,
Implementation: knownProducers[nm],
}
produces = append(produces, GenSerGroup{
AppName: ser.AppName,
ReceiverName: ser.ReceiverName,
Name: ser.Name,
MediaType: prod,
Implementation: ser.Implementation,
AllSerializers: []GenSerializer{ser},
})
}
if len(produces) == 0 {
produces = append(produces, GenSerGroup{
AppName: a.Name,
ReceiverName: a.Receiver,
Name: "json",
MediaType: runtime.JSONMime,
AllSerializers: []GenSerializer{GenSerializer{
AppName: a.Name,
ReceiverName: a.Receiver,
Name: "json",
MediaType: runtime.JSONMime,
Implementation: knownProducers["json"],
}},
Implementation: knownProducers["json"],
})
producesJSON = true
}
return
}
func (b *codeGenOpBuilder) MakeOperation() (GenOperation, error) {
if Debug {
log.Printf("[%s %s] parsing operation (id: %q)", b.Method, b.Path, b.Operation.ID)
}
resolver := newTypeResolver(b.ModelsPackage, b.Doc.ResetDefinitions())
receiver := "o"
operation := b.Operation
var params, qp, pp, hp, fp GenParameters
var hasQueryParams, hasFormParams, hasFileParams, hasFormValueParams bool
for _, p := range b.Analyzed.ParamsFor(b.Method, b.Path) {
cp, err := b.MakeParameter(receiver, resolver, p)
if err != nil {
return GenOperation{}, err
}
if cp.IsQueryParam() {
hasQueryParams = true
qp = append(qp, cp)
}
if cp.IsFormParam() {
if p.Type == "file" {
hasFileParams = true
}
if p.Type != "file" {
hasFormValueParams = true
}
hasFormParams = true
fp = append(fp, cp)
}
if cp.IsPathParam() {
pp = append(pp, cp)
}
if cp.IsHeaderParam() {
hp = append(hp, cp)
}
params = append(params, cp)
}
sort.Sort(params)
sort.Sort(qp)
sort.Sort(pp)
sort.Sort(hp)
sort.Sort(fp)
var responses map[int]GenResponse
var defaultResponse *GenResponse
var successResponse *GenResponse
if operation.Responses != nil {
for k, v := range operation.Responses.StatusCodeResponses {
isSuccess := k/100 == 2
gr, err := b.MakeResponse(receiver, swag.ToJSONName(b.Name+" "+runtime.Statuses[k]), isSuccess, resolver, k, v)
if err != nil {
return GenOperation{}, err
}
if isSuccess {
successResponse = &gr
}
if responses == nil {
responses = make(map[int]GenResponse)
}
responses[k] = gr
}
if operation.Responses.Default != nil {
gr, err := b.MakeResponse(receiver, b.Name+" default", false, resolver, -1, *operation.Responses.Default)
if err != nil {
return GenOperation{}, err
}
defaultResponse = &gr
}
}
prin := b.Principal
if prin == "" {
prin = "interface{}"
}
var extra []GenSchema
for _, sch := range b.ExtraSchemas {
extra = append(extra, sch)
}
swsp := resolver.Doc.Spec()
var extraSchemes []string
if ess, ok := operation.Extensions.GetStringSlice("x-schemes"); ok {
extraSchemes = append(extraSchemes, ess...)
}
if ess1, ok := swsp.Extensions.GetStringSlice("x-schemes"); ok {
extraSchemes = concatUnique(ess1, extraSchemes)
}
sort.Strings(extraSchemes)
schemes := concatUnique(swsp.Schemes, operation.Schemes)
sort.Strings(schemes)
produces := producesOrDefault(operation.Produces, swsp.Produces, b.DefaultProduces)
sort.Strings(produces)
consumes := producesOrDefault(operation.Consumes, swsp.Consumes, b.DefaultConsumes)
sort.Strings(consumes)
var hasStreamingResponse bool
if defaultResponse != nil && defaultResponse.Schema != nil && defaultResponse.Schema.IsStream {
hasStreamingResponse = true
}
if !hasStreamingResponse && successResponse != nil && successResponse.Schema != nil && successResponse.Schema.IsStream {
hasStreamingResponse = true
}
if !hasStreamingResponse {
for _, r := range responses {
if r.Schema != nil && r.Schema.IsStream {
hasStreamingResponse = true
break
}
}
}
return GenOperation{
Package: b.APIPackage,
RootPackage: b.RootAPIPackage,
Name: b.Name,
Method: b.Method,
Path: b.Path,
Tags: operation.Tags[:],
Description: operation.Description,
ReceiverName: receiver,
DefaultImports: b.DefaultImports,
Params: params,
Summary: operation.Summary,
QueryParams: qp,
PathParams: pp,
HeaderParams: hp,
FormParams: fp,
HasQueryParams: hasQueryParams,
HasFormParams: hasFormParams,
HasFormValueParams: hasFormValueParams,
HasFileParams: hasFileParams,
HasStreamingResponse: hasStreamingResponse,
Authorized: b.Authed,
Principal: prin,
Responses: responses,
DefaultResponse: defaultResponse,
SuccessResponse: successResponse,
ExtraSchemas: extra,
Schemes: schemeOrDefault(schemes, b.DefaultScheme),
ProducesMediaTypes: produces,
ConsumesMediaTypes: consumes,
ExtraSchemes: extraSchemes,
WithContext: b.WithContext,
}, nil
}