267 lines
9.0 KiB
Go
267 lines
9.0 KiB
Go
package api
|
|
|
|
import (
|
|
"database/sql"
|
|
"encoding/json"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
"marketing-system-data-tool/server/internal/exporter"
|
|
)
|
|
|
|
type TemplatesAPI struct{
|
|
meta *sql.DB
|
|
marketing *sql.DB
|
|
}
|
|
|
|
func TemplatesHandler(meta, marketing *sql.DB) http.Handler {
|
|
api := &TemplatesAPI{meta: meta, marketing: marketing}
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
p := strings.TrimPrefix(r.URL.Path, "/api/templates")
|
|
if r.Method == http.MethodPost && p == "" {
|
|
api.createTemplate(w, r)
|
|
return
|
|
}
|
|
if r.Method == http.MethodGet && p == "" {
|
|
api.listTemplates(w, r)
|
|
return
|
|
}
|
|
if strings.HasPrefix(p, "/") {
|
|
id := strings.TrimPrefix(p, "/")
|
|
if r.Method == http.MethodGet {
|
|
api.getTemplate(w, r, id)
|
|
return
|
|
}
|
|
if r.Method == http.MethodPatch {
|
|
api.patchTemplate(w, r, id)
|
|
return
|
|
}
|
|
if r.Method == http.MethodPost && strings.HasSuffix(p, "/validate") {
|
|
id = strings.TrimSuffix(id, "/validate")
|
|
api.validateTemplate(w, r, id)
|
|
return
|
|
}
|
|
}
|
|
w.WriteHeader(http.StatusNotFound)
|
|
})
|
|
}
|
|
|
|
type TemplatePayload struct{
|
|
Name string `json:"name"`
|
|
Datasource string `json:"datasource"`
|
|
MainTable string `json:"main_table"`
|
|
Fields []string `json:"fields"`
|
|
Filters map[string]interface{} `json:"filters"`
|
|
FileFormat string `json:"file_format"`
|
|
OwnerID uint64 `json:"owner_id"`
|
|
Visibility string `json:"visibility"`
|
|
}
|
|
|
|
func (a *TemplatesAPI) createTemplate(w http.ResponseWriter, r *http.Request) {
|
|
b, _ := io.ReadAll(r.Body)
|
|
var p TemplatePayload
|
|
json.Unmarshal(b, &p)
|
|
wl := map[string]bool{
|
|
"order.order_number": true,
|
|
"order.creator": true,
|
|
"order.out_trade_no": true,
|
|
"order.type": true,
|
|
"order.status": true,
|
|
"order.contract_price": true,
|
|
"order.num": true,
|
|
"order.total": true,
|
|
"order.pay_amount": true,
|
|
"order.create_time": true,
|
|
"order.update_time": true,
|
|
}
|
|
req := exporter.BuildRequest{MainTable: p.MainTable, Fields: p.Fields, Filters: p.Filters}
|
|
q, args, err := exporter.BuildSQL(req, wl)
|
|
if err != nil {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
w.Write([]byte(err.Error()))
|
|
return
|
|
}
|
|
_, score, err := exporter.RunExplain(a.marketing, q, args)
|
|
if err != nil {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
w.Write([]byte(err.Error()))
|
|
return
|
|
}
|
|
now := time.Now()
|
|
_, err = a.meta.Exec(
|
|
"INSERT INTO export_templates (name, datasource, main_table, fields_json, filters_json, file_format, visibility, owner_id, enabled, explain_score, last_validated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?)",
|
|
p.Name, p.Datasource, p.MainTable, toJSON(p.Fields), toJSON(p.Filters), p.FileFormat, p.Visibility, p.OwnerID, 1, score, now,
|
|
)
|
|
if err != nil {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
w.Write([]byte(err.Error()))
|
|
return
|
|
}
|
|
w.WriteHeader(http.StatusCreated)
|
|
w.Write([]byte("ok"))
|
|
}
|
|
|
|
func (a *TemplatesAPI) listTemplates(w http.ResponseWriter, r *http.Request) {
|
|
rows, err := a.meta.Query("SELECT id,name,datasource,main_table,file_format,visibility,owner_id,enabled,explain_score,last_validated_at,created_at,updated_at FROM export_templates ORDER BY updated_at DESC LIMIT 200")
|
|
if err != nil {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
w.Write([]byte(err.Error()))
|
|
return
|
|
}
|
|
defer rows.Close()
|
|
out := []map[string]interface{}{}
|
|
for rows.Next() {
|
|
var id uint64
|
|
var name, datasource, mainTable, fileFormat, visibility string
|
|
var ownerID uint64
|
|
var enabled int
|
|
var explainScore sql.NullInt64
|
|
var lastValidatedAt sql.NullTime
|
|
var createdAt, updatedAt time.Time
|
|
err := rows.Scan(&id, &name, &datasource, &mainTable, &fileFormat, &visibility, &ownerID, &enabled, &explainScore, &lastValidatedAt, &createdAt, &updatedAt)
|
|
if err != nil {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
w.Write([]byte(err.Error()))
|
|
return
|
|
}
|
|
m := map[string]interface{}{"id": id, "name": name, "datasource": datasource, "main_table": mainTable, "file_format": fileFormat, "visibility": visibility, "owner_id": ownerID, "enabled": enabled == 1, "explain_score": explainScore.Int64, "last_validated_at": lastValidatedAt.Time, "created_at": createdAt, "updated_at": updatedAt}
|
|
out = append(out, m)
|
|
}
|
|
b, _ := json.Marshal(out)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Write(b)
|
|
}
|
|
|
|
func (a *TemplatesAPI) getTemplate(w http.ResponseWriter, r *http.Request, id string) {
|
|
row := a.meta.QueryRow("SELECT id,name,datasource,main_table,fields_json,filters_json,file_format,visibility,owner_id,enabled,explain_score,last_validated_at,created_at,updated_at FROM export_templates WHERE id=?", id)
|
|
var m = map[string]interface{}{}
|
|
var tid uint64
|
|
var name, datasource, mainTable, fileFormat, visibility string
|
|
var ownerID uint64
|
|
var enabled int
|
|
var explainScore sql.NullInt64
|
|
var lastValidatedAt sql.NullTime
|
|
var createdAt, updatedAt time.Time
|
|
var fields, filters []byte
|
|
err := row.Scan(&tid, &name, &datasource, &mainTable, &fields, &filters, &fileFormat, &visibility, &ownerID, &enabled, &explainScore, &lastValidatedAt, &createdAt, &updatedAt)
|
|
if err != nil {
|
|
w.WriteHeader(http.StatusNotFound)
|
|
w.Write([]byte("not found"))
|
|
return
|
|
}
|
|
m["id"] = tid
|
|
m["name"] = name
|
|
m["datasource"] = datasource
|
|
m["main_table"] = mainTable
|
|
m["file_format"] = fileFormat
|
|
m["visibility"] = visibility
|
|
m["owner_id"] = ownerID
|
|
m["enabled"] = enabled == 1
|
|
m["explain_score"] = explainScore.Int64
|
|
m["last_validated_at"] = lastValidatedAt.Time
|
|
m["created_at"] = createdAt
|
|
m["updated_at"] = updatedAt
|
|
m["fields"] = fromJSON(fields)
|
|
m["filters"] = fromJSON(filters)
|
|
b, _ := json.Marshal(m)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Write(b)
|
|
}
|
|
|
|
func (a *TemplatesAPI) patchTemplate(w http.ResponseWriter, r *http.Request, id string) {
|
|
b, _ := io.ReadAll(r.Body)
|
|
var p map[string]interface{}
|
|
json.Unmarshal(b, &p)
|
|
set := []string{}
|
|
args := []interface{}{}
|
|
for k, v := range p {
|
|
switch k {
|
|
case "name", "visibility", "file_format":
|
|
set = append(set, k+"=?")
|
|
args = append(args, v)
|
|
case "enabled":
|
|
set = append(set, "enabled=?")
|
|
if v.(bool) {
|
|
args = append(args, 1)
|
|
} else {
|
|
args = append(args, 0)
|
|
}
|
|
}
|
|
}
|
|
if len(set) == 0 {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
w.Write([]byte("no patch"))
|
|
return
|
|
}
|
|
args = append(args, id)
|
|
_, err := a.meta.Exec("UPDATE export_templates SET "+strings.Join(set, ",")+" WHERE id=?", args...)
|
|
if err != nil {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
w.Write([]byte(err.Error()))
|
|
return
|
|
}
|
|
w.Write([]byte("ok"))
|
|
}
|
|
|
|
func (a *TemplatesAPI) validateTemplate(w http.ResponseWriter, r *http.Request, id string) {
|
|
row := a.meta.QueryRow("SELECT main_table, fields_json, filters_json FROM export_templates WHERE id=?", id)
|
|
var main string
|
|
var fields, filters []byte
|
|
err := row.Scan(&main, &fields, &filters)
|
|
if err != nil {
|
|
w.WriteHeader(http.StatusNotFound)
|
|
w.Write([]byte("not found"))
|
|
return
|
|
}
|
|
var fs []string
|
|
var fl map[string]interface{}
|
|
json.Unmarshal(fields, &fs)
|
|
json.Unmarshal(filters, &fl)
|
|
wl := map[string]bool{
|
|
"order.order_number": true,
|
|
"order.creator": true,
|
|
"order.out_trade_no": true,
|
|
"order.type": true,
|
|
"order.status": true,
|
|
"order.contract_price": true,
|
|
"order.num": true,
|
|
"order.total": true,
|
|
"order.pay_amount": true,
|
|
"order.create_time": true,
|
|
"order.update_time": true,
|
|
}
|
|
req := exporter.BuildRequest{MainTable: main, Fields: fs, Filters: fl}
|
|
q, args, err := exporter.BuildSQL(req, wl)
|
|
if err != nil {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
w.Write([]byte(err.Error()))
|
|
return
|
|
}
|
|
_, score, err := exporter.RunExplain(a.marketing, q, args)
|
|
if err != nil {
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
w.Write([]byte(err.Error()))
|
|
return
|
|
}
|
|
now := time.Now()
|
|
_, err = a.meta.Exec("UPDATE export_templates SET explain_score=?, last_validated_at=? WHERE id=?", score, now, id)
|
|
if err != nil {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
w.Write([]byte(err.Error()))
|
|
return
|
|
}
|
|
w.Write([]byte("ok"))
|
|
}
|
|
|
|
func toJSON(v interface{}) []byte {
|
|
b, _ := json.Marshal(v)
|
|
return b
|
|
}
|
|
|
|
func fromJSON(b []byte) interface{} {
|
|
var v interface{}
|
|
json.Unmarshal(b, &v)
|
|
return v
|
|
}
|