// 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 (a *appGenerator) Generate() error {
app, err := a.makeCodegenApp()
if err != nil {
return err
}
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
}
importPath := filepath.ToSlash(filepath.Join(baseImport(a.Target), a.ServerPackage, a.APIPackage))
app.DefaultImports = append(app.DefaultImports, importPath)
if err := a.generateConfigureAPI(&app); err != nil {
return err
}
if err := a.generateMain(&app); err != nil {
return err
}
return nil
}
func (m *definitionGenerator) Generate() error {
mod, err := makeGenDefinition(m.Name, m.Target, m.Model, m.SpecDoc)
if err != nil {
return err
}
if m.DumpData {
bb, _ := json.MarshalIndent(swag.ToDynamicJSON(mod), "", " ")
fmt.Fprintln(os.Stdout, string(bb))
return nil
}
mod.IncludeValidator = m.IncludeValidator
m.Data = mod
if m.IncludeModel {
if err := m.generateModel(); err != nil {
return fmt.Errorf("model: %s", err)
}
}
log.Println("generated model", m.Name)
return nil
}
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
var bldr codeGenOpBuilder
bldr.Name = o.Name
bldr.ModelsPackage = o.ModelsPackage
bldr.Principal = o.Principal
bldr.Target = o.Target
bldr.Operation = o.Operation
bldr.Authed = authed
bldr.Doc = o.Doc
//bldr.DefaultImports = []string{filepath.ToSlash(filepath.Join(baseImport(o.Target), o.ModelsPackage))}
for _, tag := range o.Operation.Tags {
if len(o.Tags) == 0 {
bldr.APIPackage = tag
op, err := bldr.MakeOperation()
if err != nil {
return err
}
operations = append(operations, op)
continue
}
for _, ft := range o.Tags {
if ft == tag {
bldr.APIPackage = tag
op, err := bldr.MakeOperation()
if err != nil {
return err
}
operations = append(operations, op)
break
}
}
}
if len(operations) == 0 {
bldr.APIPackage = o.APIPackage
op, err := bldr.MakeOperation()
if err != nil {
return err
}
operations = append(operations, op)
}
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 = swag.ToGoName(op.Name)
if o.IncludeHandler {
if err := o.generateHandler(); err != nil {
return fmt.Errorf("handler: %s", err)
}
log.Println("generated handler", op.Package+"."+o.cname)
}
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+"."+o.cname+"Parameters")
}
if len(o.Operation.Parameters) == 0 {
log.Println("no parameters for operation", op.Package+"."+o.cname)
}
}
return nil
}
