// Generate generates all python server files
func (ps Server) Generate(dir string) error {
globAPIDef = ps.APIDef
// generate input validators helper
if err := commons.GenerateFile(struct{}{}, "./templates/input_validators_python.tmpl", "input_validators_python",
filepath.Join(dir, "input_validators.py"), false); err != nil {
return err
}
// generate request body
if err := generateClassesFromBodies(getAllResources(ps.APIDef, true), dir); err != nil {
return err
}
// python classes
if err := generateClasses(ps.APIDef.Types, dir); err != nil {
log.Errorf("failed to generate python clased:%v", err)
return err
}
// security scheme
if err := generateSecurity(ps.APIDef.SecuritySchemes, dir); err != nil {
log.Errorf("failed to generate security scheme:%v", err)
return err
}
// genereate resources
rds, err := generateServerResources(ps.APIDef, dir)
if err != nil {
return err
}
ps.ResourcesDef = rds
// libraries
if err := generateLibraries(ps.APIDef.Libraries, dir); err != nil {
return err
}
// requirements.txt file
if err := commons.GenerateFile(nil, "./templates/requirements_python.tmpl", "requirements_python", filepath.Join(dir, "requirements.txt"), false); err != nil {
return err
}
// generate main
if ps.WithMain {
// generate HTML front page
if err := commons.GenerateFile(ps, "./templates/index.html.tmpl", "index.html", filepath.Join(dir, "index.html"), false); err != nil {
return err
}
// main file
return commons.GenerateFile(ps, "./templates/server_main_python.tmpl", "server_main_python", filepath.Join(dir, "app.py"), true)
}
return nil
}
// Generate generates all Go server files
func (gs Server) Generate(dir string) error {
// helper package
gh := goramlHelper{
rootImportPath: gs.RootImportPath,
packageName: "goraml",
packageDir: "goraml",
}
if err := gh.generate(dir); err != nil {
return err
}
// generate all Type structs
if err := generateStructs(gs.apiDef.Types, dir, gs.PackageName); err != nil {
return err
}
// generate all request & response body
if err := generateBodyStructs(gs.apiDef, dir, gs.PackageName, langGo); err != nil {
return err
}
// security scheme
if err := generateSecurity(gs.apiDef.SecuritySchemes, dir, gs.PackageName); err != nil {
log.Errorf("failed to generate security scheme:%v", err)
return err
}
// genereate resources
rds, err := generateServerResources(gs.apiDef, dir, gs.PackageName)
if err != nil {
return err
}
gs.ResourcesDef = rds
// libraries
if err := generateLibraries(gs.apiDef.Libraries, dir); err != nil {
return err
}
// generate main
if gs.withMain {
// HTML front page
if err := commons.GenerateFile(gs, "./templates/index.html.tmpl", "index.html", filepath.Join(dir, "index.html"), false); err != nil {
return err
}
// main file
return commons.GenerateFile(gs, "./templates/server_main_go.tmpl", "server_main_go", filepath.Join(dir, "main.go"), true)
}
return nil
}
// Generate generates struct code
func (s *Struct) Generate(dir string) error {
if err := s.generateEnums(dir); err != nil {
return err
}
filename := filepath.Join(dir, s.Name+".capnp")
return commons.GenerateFile(s, "./templates/struct_capnp.tmpl", "struct_capnp", filename, true)
}
// Generate generates all Nim server files
func (s *Server) Generate() error {
s.Resources = getAllResources(s.APIDef, true)
// generate all objects from all RAML types
if err := generateObjects(s.APIDef.Types, s.Dir); err != nil {
return err
}
// generate all objects from request/response body
if _, err := generateObjectsFromBodies(s.Resources, s.Dir); err != nil {
return err
}
// main file
if err := s.generateMain(); err != nil {
return err
}
// API implementation
if err := generateResourceAPIs(s.Resources, s.Dir); err != nil {
return err
}
// HTML front page
if err := commons.GenerateFile(s, "./templates/index.html.tmpl", "index.html", filepath.Join(s.Dir, "index.html"), false); err != nil {
return err
}
return nil
}
func (dg dateGen) generate(dir string) error {
dates := []struct {
Type string
Format string
FileName string
}{
{"date-only", "", "date_only.go"},
{"time-only", "", "time_only.go"},
{"datetime-only", "", "datetime_only.go"},
{"datetime", "RFC3339", "datetime.go"},
{"datetime", "RFC2616", "datetime_rfc2616.go"},
}
for _, d := range dates {
b, err := date.Get(d.Type, d.Format)
if err != nil {
return err
}
ctx := map[string]interface{}{
"PackageName": dg.PackageName,
"Content": string(b),
}
err = commons.GenerateFile(ctx, "./templates/date.tmpl", "date", filepath.Join(dir, d.FileName), false)
if err != nil {
return err
}
}
return nil
}
// generate nim object representation
func (o *object) generate(dir string) error {
filename := filepath.Join(dir, o.Name+".nim")
if err := commons.GenerateFile(o, "./templates/object_nim.tmpl", "object_nim", filename, true); err != nil {
return err
}
registerObject(o)
return nil
}
func (gc *Client) generateServices(dir string) error {
for _, s := range gc.Services {
sort.Sort(resource.ByEndpoint(s.Methods))
if err := commons.GenerateFile(s, "./templates/client_service_go.tmpl", "client_service_go", s.filename(dir), false); err != nil {
return err
}
}
return nil
}
// generate input validator helper file
func generateInputValidator(packageName, dir string) error {
var ctx = struct {
PackageName string
}{
PackageName: packageName,
}
fileName := filepath.Join(dir, inputValidatorFileResult)
return commons.GenerateFile(ctx, inputValidatorTemplateLocation, "struct_input_validator_template", fileName, true)
}
// Generate generates python client library files
func (c Client) Generate(dir string) error {
globAPIDef = c.APIDef
// generate empty __init__.py
if err := generateEmptyInitPy(dir); err != nil {
return err
}
// generate helper
if err := commons.GenerateFile(nil, "./templates/client_utils_python.tmpl", "client_utils_python", filepath.Join(dir, "client_utils.py"), false); err != nil {
return err
}
if err := c.generateServices(dir); err != nil {
return err
}
// generate main client lib file
return commons.GenerateFile(c, "./templates/client_python.tmpl", "client_python", filepath.Join(dir, "client.py"), true)
}
// generate Go client lib file
func (gc *Client) generateClientFile(dir string) error {
fileName := filepath.Join(dir, "/client_"+strings.ToLower(gc.Name)+".go")
return commons.GenerateFile(gc, "./templates/client_go.tmpl", "client_go", fileName, false)
}
// generate Go struct
func (sd structDef) generate(dir string) error {
fileName := filepath.Join(dir, sd.Name+".go")
return commons.GenerateFile(sd, structTemplateLocation, "struct_template", fileName, false)
}
func (c *Client) generateMain() error {
filename := filepath.Join(c.Dir, "client.nim")
return commons.GenerateFile(c, "./templates/client_nim.tmpl", "client_nim", filename, true)
}
func (cs *clientService) generate(dir string) error {
filename := filepath.Join(dir, cs.Name+"_service.nim")
return commons.GenerateFile(cs, "./templates/client_service_nim.tmpl", "client_service_nim", filename, true)
}
// generate interface file of a resource
func (gr *goResource) generateInterfaceFile(directory string) error {
filename := directory + "/" + strings.ToLower(gr.Name) + "_if.go"
return commons.GenerateFile(gr, resourceIfTemplate, "resource_if_template", filename, true)
}
func (r *resource) generate(dir string) error {
filename := filepath.Join(dir, r.apiName()+".nim")
return commons.GenerateFile(r, "./templates/server_resources_api_nim.tmpl", "server_resources_api_nim", filename, true)
}
// generate Go client helper
func (gc *Client) generateHelperFile(dir string) error {
fileName := filepath.Join(dir, "/client_utils.go")
return commons.GenerateFile(gc, "./templates/client_utils_go.tmpl", "client_utils_go", fileName, false)
}
// generate Go representation of a security scheme
// it implemented as struct based middleware
func (gs *goSecurity) generate(dir string) error {
fileName := path.Join(dir, "oauth2_"+gs.Name+"_middleware.go")
return commons.GenerateFile(gs, "./templates/oauth2_middleware.tmpl", "oauth2_middleware", fileName, false)
}
func (e *enum) generate(dir string) error {
filename := filepath.Join(dir, e.Name+".capnp")
return commons.GenerateFile(e, "./templates/enum_capnp.tmpl", "enum_capnp", filename, true)
}
// generate security schheme representation in python.
// security scheme is generated as a middleware
func (ps *pythonSecurity) generate(dir string) error {
fileName := path.Join(dir, "oauth2_"+ps.Name+".py")
return commons.GenerateFile(ps, "./templates/oauth2_middleware_python.tmpl", "oauth2_middleware_python", fileName, false)
}
// generate a python class file
func (pc *class) generate(dir string) error {
fileName := filepath.Join(dir, pc.Name+".py")
return commons.GenerateFile(pc, "./templates/class_python.tmpl", "class_python", fileName, false)
}
// main generates main file
func (s *Server) generateMain() error {
filename := filepath.Join(s.Dir, "main.nim")
return commons.GenerateFile(s, "./templates/server_main_nim.tmpl", "server_main_nim", filename, true)
}
// generate API file of a resource
func (gr *goResource) generateAPIFile(directory string) error {
filename := directory + "/" + strings.ToLower(gr.Name) + "_api.go"
return commons.GenerateFile(gr, resourceAPITemplate, "resource_api_template", filename, false)
}
// generate flask representation of an RAML resource
// It has one file : an API route and implementation
func (pr *pythonResource) generate(r *raml.Resource, URI, dir string) error {
pr.GenerateMethods(r, "python", newServerMethod, newClientMethod)
pr.setMiddlewares()
filename := dir + "/" + strings.ToLower(pr.Name) + ".py"
return commons.GenerateFile(pr, resourcePyTemplate, "resource_python_template", filename, true)
}
// generate empty __init__.py without overwrite it
func generateEmptyInitPy(dir string) error {
return commons.GenerateFile(nil, "./templates/init_py.tmpl", "init_py", filepath.Join(dir, "__init__.py"), false)
}