func (m *modelGenerator) Generate() error {
mod := makeCodegenModel(m.Name, m.Target, m.Model, m.SpecDoc)
if m.DumpData {
bb, _ := json.MarshalIndent(swag.ToDynamicJSON(mod), "", " ")
fmt.Fprintln(os.Stdout, string(bb))
return nil
}
m.Data = mod
if m.IncludeModel {
if err := m.generateModel(); err != nil {
return fmt.Errorf("model: %s", err)
}
}
log.Println("generated model", m.Name)
if m.IncludeValidator {
if err := m.generateValidator(); err != nil {
return fmt.Errorf("validator: %s", err)
}
}
log.Println("generated validator", m.Name)
return nil
}
// Validate validates the data against the schema
func (s *SchemaValidator) Validate(data interface{}) *Result {
if data == nil {
v := s.validators[0].Validate(data)
v.Merge(s.validators[6].Validate(data))
return v
}
result := new(Result)
tpe := reflect.TypeOf(data)
kind := tpe.Kind()
for kind == reflect.Ptr {
tpe = tpe.Elem()
kind = tpe.Kind()
}
d := data
if kind == reflect.Struct {
d = swag.ToDynamicJSON(data)
}
for _, v := range s.validators {
if !v.Applies(s.Schema, kind) {
continue
}
err := v.Validate(d)
result.Merge(err)
result.Inc()
}
result.Inc()
return result
}
func (o *operationGenerator) Generate() error {
// Build a list of codegen operations based on the tags,
// the tag decides the actual package for an operation
// the user specified package serves as root for generating the directory structure
var operations []genOperation
authed := len(o.SecurityRequirements) > 0
for _, tag := range o.Operation.Tags {
if len(o.Tags) == 0 {
operations = append(operations, makeCodegenOperation(o.Name, tag, o.ModelsPackage, o.Principal, o.Target, o.Operation, authed))
continue
}
for _, ft := range o.Tags {
if ft == tag {
operations = append(operations, makeCodegenOperation(o.Name, tag, o.ModelsPackage, o.Principal, o.Target, o.Operation, authed))
break
}
}
}
if len(operations) == 0 {
operations = append(operations, makeCodegenOperation(o.Name, o.APIPackage, o.ModelsPackage, o.Principal, o.Target, o.Operation, authed))
}
for _, op := range operations {
if o.DumpData {
bb, _ := json.MarshalIndent(swag.ToDynamicJSON(op), "", " ")
fmt.Fprintln(os.Stdout, string(bb))
continue
}
o.data = op
o.pkg = op.Package
o.cname = op.ClassName
if o.IncludeHandler {
if err := o.generateHandler(); err != nil {
return fmt.Errorf("handler: %s", err)
}
log.Println("generated handler", op.Package+"."+op.ClassName)
}
if o.IncludeParameters && len(o.Operation.Parameters) > 0 {
if err := o.generateParameterModel(); err != nil {
return fmt.Errorf("parameters: %s", err)
}
log.Println("generated parameters", op.Package+"."+op.ClassName+"Parameters")
}
if len(o.Operation.Parameters) == 0 {
log.Println("no parameters for operation", op.Package+"."+op.ClassName)
}
}
return nil
}
func (a *appGenerator) Generate() error {
app := a.makeCodegenApp()
if a.DumpData {
bb, _ := json.MarshalIndent(swag.ToDynamicJSON(app), "", " ")
fmt.Fprintln(os.Stdout, string(bb))
return nil
}
if err := a.generateAPIBuilder(&app); err != nil {
return err
}
app.DefaultImports = append(app.DefaultImports, filepath.Join(baseImport(a.Target), a.ServerPackage, a.APIPackage))
if err := a.generateConfigureAPI(&app); err != nil {
return err
}
if err := a.generateMain(&app); err != nil {
return err
}
return nil
}
