func paramValidations(receiver string, param spec.Parameter) commonValidations {
accessor := swag.ToGoName(param.Name)
paramName := swag.ToJSONName(param.Name)
tpe := typeForParameter(param)
_, isPrimitive := primitives[tpe]
_, isCustomFormatter := customFormatters[tpe]
return commonValidations{
propertyDescriptor: propertyDescriptor{
PropertyName: accessor,
ParamName: paramName,
ValueExpression: fmt.Sprintf("%s.%s", receiver, accessor),
IndexVar: "i",
Path: "\"" + paramName + "\"",
IsContainer: param.Items != nil || tpe == "array",
IsPrimitive: isPrimitive,
IsCustomFormatter: isCustomFormatter,
IsMap: strings.HasPrefix(tpe, "map"),
},
sharedValidations: sharedValidations{
Required: param.Required,
Maximum: param.Maximum,
ExclusiveMaximum: param.ExclusiveMaximum,
Minimum: param.Minimum,
ExclusiveMinimum: param.ExclusiveMinimum,
MaxLength: param.MaxLength,
MinLength: param.MinLength,
Pattern: param.Pattern,
MaxItems: param.MaxItems,
MinItems: param.MinItems,
UniqueItems: param.UniqueItems,
MultipleOf: param.MultipleOf,
Enum: param.Enum,
},
Type: tpe,
Format: param.Format,
Items: param.Items,
Default: param.Default,
}
}
func (a *appGenerator) makeConsumes() (consumes []GenSerGroup, consumesJSON bool) {
for _, cons := range a.SpecDoc.RequiredConsumes() {
cn, ok := mediaTypeNames[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,
})
}
return
}
func (a *appGenerator) makeProduces() (produces []GenSerGroup, producesJSON bool) {
for _, prod := range a.SpecDoc.RequiredProduces() {
pn, ok := mediaTypeNames[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},
})
}
return
}
func (b *codeGenOpBuilder) MakeOperation() (GenOperation, error) {
resolver := typeResolver{ModelsPackage: b.ModelsPackage, Doc: b.Doc}
receiver := "o"
operation := b.Operation
var params, qp, pp, hp, fp []GenParameter
var hasQueryParams bool
for _, p := range operation.Parameters {
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() {
fp = append(fp, cp)
}
if cp.IsPathParam() {
pp = append(pp, cp)
}
if cp.IsHeaderParam() {
hp = append(hp, cp)
}
params = append(params, cp)
}
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+" "+httpkit.Statuses[k]), isSuccess, &resolver, 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, *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)
}
return GenOperation{
Package: b.APIPackage,
Name: b.Name,
Description: operation.Description,
ReceiverName: receiver,
DefaultImports: b.DefaultImports,
Params: params,
Summary: operation.Summary,
QueryParams: qp,
PathParams: pp,
HeaderParams: hp,
FormParams: fp,
HasQueryParams: hasQueryParams,
Authorized: b.Authed,
Principal: prin,
Responses: responses,
DefaultResponse: defaultResponse,
SuccessResponse: successResponse,
ExtraSchemas: extra,
}, nil
}