rest/api.go

package rest

import (
	"fmt"
	"git.nspix.com/golang/micro/gateway/http"
	"git.nspix.com/golang/rest/v3/cache"
	"gorm.io/gorm"
)

type Api struct {
	crud *CRUD
}

func (api *Api) handleListSchema(httpCtx *http.Context) (err error) {
	var (
		schemas []*Schema
	)
	ns := httpCtx.FormValue(NamespaceVariable)
	if ns == "" {
		ns = DefaultNamespace
	}
	if schemas, err = api.crud.GetSchemas(httpCtx.Request().Context(), ns, httpCtx.ParamValue("module"), httpCtx.ParamValue("table")); err == nil {
		return httpCtx.Success(schemas)
	} else {
		return httpCtx.Error(HttpDatabaseQueryFailed, err.Error())
	}
}

func (api *Api) handleSaveSchema(httpCtx *http.Context) (err error) {
	var (
		rest *Restful
	)
	ns := httpCtx.FormValue(NamespaceVariable)
	if ns == "" {
		ns = DefaultNamespace
	}
	moduleName := httpCtx.ParamValue("module")
	tableName := httpCtx.ParamValue("table")
	for _, row := range api.crud.modules {
		if row.model.ModuleName() == moduleName && row.model.TableName() == tableName {
			rest = row
			break
		}
	}
	if rest == nil {
		return httpCtx.Error(HTTPUnknownFailed, fmt.Sprintf("module %s table %s schema not found", moduleName, tableName))
	}
	schemas := make([]*Schema, 0)
	if err = httpCtx.Bind(&schemas); err != nil {
		return httpCtx.Error(HttpInvalidPayload, err.Error())
	}
	if err = api.crud.db.Transaction(func(tx *gorm.DB) error {
		var (
			errTx error
		)
		for _, scm := range schemas {
			if errTx = tx.Save(scm).Error; errTx != nil {
				return errTx
			}
		}
		return nil
	}); err == nil {
		if api.crud.enableCache {
			cache.Delete(fmt.Sprintf("schema:%s:%s:%s", ns, moduleName, tableName))
		}
		return httpCtx.Success(map[string]interface{}{
			"count": len(schemas),
			"state": "success",
		})
	} else {
		return httpCtx.Error(HTTPUnknownFailed, err.Error())
	}
}

func (api *Api) handleListSchemas(httpCtx *http.Context) (err error) {
	var (
		moduleLabel string
	)
	ts := make([]*treeValue, 0)
	isHandled := false
	for _, e := range api.crud.modules {
		isHandled = false
		for _, tv := range ts {
			if tv.Value == e.model.ModuleName() {
				tv.Append(&treeValue{Value: e.model.TableName(), Label: e.model.TableName(), Type: TypeTable})
				isHandled = true
				break
			}
		}
		if isHandled {
			continue
		}
		moduleLabel = e.model.ModuleName()
		tv := &treeValue{Label: moduleLabel, Value: e.model.ModuleName(), Type: TypeModule}
		tv.Append(&treeValue{Value: e.model.TableName(), Label: e.model.TableName(), Type: TypeTable})
		ts = append(ts, tv)
	}
	return httpCtx.Success(ts)
}

func (api *Api) handleDeleteSchema(httpCtx *http.Context) (err error) {
	id := httpCtx.ParamValue("id")
	model := &Schema{}
	if err = api.crud.db.Where("id=?", id).First(model).Error; err == nil {
		if err = api.crud.db.Where("id=?", id).Delete(&Schema{}).Error; err == nil {
			if api.crud.enableCache {
				cache.Delete(fmt.Sprintf("schema:%s:%s:%s", model.Namespace, model.ModuleName, model.TableName))
			}
			return httpCtx.Success(map[string]string{
				"id":    id,
				"state": "success",
			})
		} else {
			return httpCtx.Error(HttpDatabaseDeleteFailed, err.Error())
		}
	} else {
		return httpCtx.Error(HttpDatabaseFindFailed, err.Error())
	}
}

func (api *Api) Router(svr *http.Server, ms ...http.Middleware) {
	svr.Handle("GET", "/rest/schemas", api.handleListSchemas, ms...)
	svr.Handle("GET", "/rest/schema/:module/:table", api.handleListSchema, ms...)
	svr.Handle("PUT", "/rest/schema/:module/:table", api.handleSaveSchema, ms...)
	svr.Handle("DELETE", "/rest/schema/:id", api.handleDeleteSchema, ms...)

	for _, rest := range api.crud.modules {
		if rest.hasScenario(ScenarioList) {
			svr.Handle("GET", rest.getScenarioUrl(ScenarioList), rest.getScenarioHandle(ScenarioList), ms...)
		}
		if rest.hasScenario(ScenarioCreate) {
			svr.Handle("POST", rest.getScenarioUrl(ScenarioCreate), rest.getScenarioHandle(ScenarioCreate), ms...)
		}
		if rest.hasScenario(ScenarioUpdate) {
			svr.Handle("PUT", rest.getScenarioUrl(ScenarioUpdate), rest.getScenarioHandle(ScenarioUpdate), ms...)
		}
		if rest.hasScenario(ScenarioDelete) {
			svr.Handle("DELETE", rest.getScenarioUrl(ScenarioDelete), rest.getScenarioHandle(ScenarioDelete), ms...)
		}
		if rest.hasScenario(ScenarioExport) {
			svr.Handle("GET", rest.getScenarioUrl(ScenarioExport), rest.getScenarioHandle(ScenarioExport), ms...)
		}
		if rest.hasScenario(ScenarioView) {
			svr.Handle("GET", rest.getScenarioUrl(ScenarioView), rest.getScenarioHandle(ScenarioView), ms...)
		}
	}
}