golib/infra/svc/svc_http.go

package svc

import (
	"encoding/json"
	"fmt"
	"net/http"

	"golib/features/mo"
	"golib/infra/ii"
	"golib/network"
)

func NewHTTPHandler(items ii.Items) http.Handler {
	return &httpHandler{items: items}
}

const (
	// Method Post
	cmdInsertOne  = "insertOne"
	cmdInsertMany = "insertMany"
	cmdUpdateOne  = "updateOne"
	cmdUpdateMany = "updateMany"
	cmdUpdateById = "updateById"
	cmdFindOne    = "findOne"
	cmdFind       = "find"
	cmdCount      = "count"
	cmdDeleteOne  = "deleteOne"
	cmdDeleteMany = "deleteMany"
)

var (
	actionMap = map[string]struct{}{
		cmdInsertOne:  {},
		cmdInsertMany: {},
		cmdUpdateOne:  {},
		cmdUpdateMany: {},
		cmdUpdateById: {},
		cmdDeleteOne:  {},
		cmdDeleteMany: {},
		cmdFind:       {},
		cmdFindOne:    {},
		cmdCount:      {},
	}
)

// action: insertOne/insertMany/updateOne/updateMany/deleteOne/deleteMany/find/findOne
// Request: {"action":"insert", "itemName":"test.test", "fields": {"name":"xiaoming","age":3.1415}}
// Response: {"action":"insert", "itemName": "test.test", "ret":"success", "result":"","fields":{"name":"required"}}

type httpHandleBody struct {
	CMD      string `json:"cmd"` // CMD 本次请求需要执行的命令
	ItemName string `json:"itemName"`
	Data     any    `json:"data"` // Data 数据类型根据 action 变化
	ExtData  any    `json:"extData"`
}

type httpHandler struct {
	items ii.Items
	user  ii.User
}

func (f *httpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	cmd, itemName, err := ii.SplitPATH(r.URL.Path)
	if err != nil {
		http.Error(w, err.Error(), http.StatusForbidden)
		return
	}
	if _, ok := actionMap[cmd]; !ok {
		http.Error(w, "unknown cmd", http.StatusNotFound)
		return
	}
	if _, ok := f.items.Has(itemName); !ok {
		http.Error(w, ErrItemNotfound.Error(), http.StatusNotFound)
		return
	}
	b, err := network.HTTP.ReadRequestBody(w, r, 4096)
	if err != nil {
		network.HTTP.Error(w, http.StatusBadRequest)
		return
	}
	var hrb httpHandleBody
	if err = json.Unmarshal(b, &hrb); err != nil {
		network.HTTP.Error(w, http.StatusBadRequest)
		return
	}
	hrb.ItemName = itemName
	hrb.CMD = cmd
	switch hrb.CMD {
	case cmdInsertOne:
		f.handleInsertOne(w, &hrb)
	case cmdInsertMany:
		f.handleInsertMany(w, &hrb)
	case cmdUpdateOne:
		f.handleUpdateOne(w, &hrb)
	case cmdUpdateMany:
		f.handleUpdateMany(w, &hrb)
	case cmdUpdateById:
		f.handleUpdateByID(w, &hrb)
	case cmdDeleteOne:
		f.handleDeleteOne(w, &hrb)
	case cmdDeleteMany:
		f.handleDeleteMany(w, &hrb)
	case cmdFindOne:
		f.handleFindOne(w, &hrb)
	case cmdFind:
		f.handleFind(w, &hrb)
	case cmdCount:
		f.handleCount(w, &hrb)
	}
}

func (f *httpHandler) handleFind(w http.ResponseWriter, hrb *httpHandleBody) {
	filter, err := f.handleFilterData(hrb.Data)
	if err != nil {
		f.respJsonErr(w, err, http.StatusBadRequest)
		return
	}
	rows, err := svc.Find(hrb.ItemName, filter)
	if err != nil {
		f.respJsonErr(w, err, http.StatusInternalServerError)
		return
	}
	resp := &httpHandleBody{
		CMD:      hrb.CMD,
		ItemName: hrb.ItemName,
		Data:     rows,
	}
	f.respJson(w, resp)
}

func (f *httpHandler) handleFindOne(w http.ResponseWriter, hrb *httpHandleBody) {
	filter, err := f.handleFilterData(hrb.Data)
	if err != nil {
		f.respJsonErr(w, err, http.StatusBadRequest)
		return
	}
	row, err := svc.FindOne(hrb.ItemName, filter)
	if err != nil {
		f.respJsonErr(w, err, http.StatusInternalServerError)
		return
	}
	resp := &httpHandleBody{
		CMD:      hrb.CMD,
		ItemName: hrb.ItemName,
		Data:     row,
	}
	f.respJson(w, resp)
}

func (f *httpHandler) handleInsertOne(w http.ResponseWriter, hrb *httpHandleBody) {
	data, ok := hrb.Data.(map[string]interface{})
	if !ok {
		f.respJsonErr(w, ErrDataError, http.StatusBadRequest)
		return
	}
	oid, err := svc.InsertOne(hrb.ItemName, data)
	if err != nil {
		f.respJsonErr(w, err, http.StatusInternalServerError)
		return
	}
	resp := &httpHandleBody{
		CMD:      hrb.CMD,
		ItemName: hrb.ItemName,
		Data:     oid,
	}
	f.respJson(w, resp)
}

func (f *httpHandler) handleInsertMany(w http.ResponseWriter, hrb *httpHandleBody) {
	data, ok := hrb.Data.([]interface{})
	if !ok {
		f.respJsonErr(w, ErrDataError, http.StatusBadRequest)
		return
	}
	oidList, err := svc.InsertMany(hrb.ItemName, data)
	if err != nil {
		f.respJsonErr(w, err, http.StatusInternalServerError)
		return
	}
	resp := &httpHandleBody{
		CMD:      hrb.CMD,
		ItemName: hrb.ItemName,
		Data:     oidList,
	}
	f.respJson(w, resp)
}

func (f *httpHandler) handleUpdateOne(w http.ResponseWriter, hrb *httpHandleBody) {
	filter, update, err := f.handleUpdateData(hrb)
	if err != nil {
		f.respJsonErr(w, err, http.StatusBadRequest)
		return
	}
	if err = svc.UpdateOne(hrb.ItemName, filter, update); err != nil {
		f.respJsonErr(w, err, http.StatusInternalServerError)
		return
	}
	resp := &httpHandleBody{
		CMD:      hrb.CMD,
		ItemName: hrb.ItemName,
		Data:     nil,
	}
	f.respJson(w, resp)
}

func (f *httpHandler) handleUpdateByID(w http.ResponseWriter, hrb *httpHandleBody) {
	idStr, ok := hrb.Data.(string)
	if !ok {
		f.respJsonErr(w, ErrDataError, http.StatusBadRequest)
		return
	}
	oid, err := mo.ID.From(idStr)
	if err != nil {
		f.respJsonErr(w, ErrDataError, http.StatusBadRequest)
		return
	}
	update, ok := hrb.ExtData.(map[string]interface{})
	if !ok {
		f.respJsonErr(w, ErrDataError, http.StatusBadRequest)
		return
	}
	if err = svc.UpdateByID(hrb.ItemName, oid, update); err != nil {
		f.respJsonErr(w, err, http.StatusInternalServerError)
		return
	}
	resp := &httpHandleBody{
		CMD:      hrb.CMD,
		ItemName: hrb.ItemName,
		Data:     nil,
	}
	f.respJson(w, resp)
}

func (f *httpHandler) handleUpdateMany(w http.ResponseWriter, hrb *httpHandleBody) {
	filter, update, err := f.handleUpdateData(hrb)
	if err != nil {
		f.respJsonErr(w, err, http.StatusBadRequest)
		return
	}
	if err = svc.UpdateMany(hrb.ItemName, filter, update); err != nil {
		f.respJsonErr(w, err, http.StatusInternalServerError)
		return
	}
	resp := &httpHandleBody{
		CMD:      hrb.CMD,
		ItemName: hrb.ItemName,
		Data:     nil,
	}
	f.respJson(w, resp)
}

func (f *httpHandler) handleCount(w http.ResponseWriter, hrb *httpHandleBody) {
	var (
		total int64
		err   error
	)
	if hrb.Data == nil || hrb.Data == "" {
		total, err = svc.EstimatedDocumentCount(hrb.ItemName)
	} else {
		filter, err := f.handleFilterData(hrb.Data)
		if err != nil {
			f.respJsonErr(w, err, http.StatusBadRequest)
			return
		}
		total, err = svc.CountDocuments(hrb.ItemName, filter)
	}
	if err != nil {
		f.respJsonErr(w, err, http.StatusInternalServerError)
		return
	}
	resp := &httpHandleBody{
		CMD:      hrb.CMD,
		ItemName: hrb.ItemName,
		Data:     total,
	}
	f.respJson(w, resp)
}

func (f *httpHandler) handleDeleteOne(w http.ResponseWriter, hrb *httpHandleBody) {
	filter, err := f.handleFilterData(hrb.Data)
	if err != nil {
		f.respJsonErr(w, err, http.StatusBadRequest)
		return
	}
	if err = svc.DeleteOne(hrb.ItemName, filter); err != nil {
		f.respJsonErr(w, err, http.StatusInternalServerError)
		return
	}
	resp := &httpHandleBody{
		CMD:      hrb.CMD,
		ItemName: hrb.ItemName,
		Data:     nil,
	}
	f.respJson(w, resp)
}

func (f *httpHandler) handleDeleteMany(w http.ResponseWriter, hrb *httpHandleBody) {
	filter, err := f.handleFilterData(hrb.Data)
	if err != nil {
		f.respJsonErr(w, err, http.StatusBadRequest)
		return
	}
	if err = svc.DeleteMany(hrb.ItemName, filter); err != nil {
		f.respJsonErr(w, err, http.StatusInternalServerError)
		return
	}
	resp := &httpHandleBody{
		CMD:      hrb.CMD,
		ItemName: hrb.ItemName,
		Data:     nil,
	}
	f.respJson(w, resp)
}

func (f *httpHandler) handleUpdateData(hrb *httpHandleBody) (mo.D, mo.M, error) {
	filter, err := f.handleFilterData(hrb.Data)
	if err != nil {
		return nil, nil, err
	}
	update, ok := hrb.ExtData.(map[string]interface{})
	if !ok {
		return nil, nil, err
	}
	return filter, update, nil
}

func (f *httpHandler) handleFilterData(data any) (mo.D, error) {
	b, err := mo.MarshalExtJSON(data, false, true)
	if err != nil {
		return nil, err
	}
	var filter mo.D
	if err = mo.UnmarshalExtJSON(b, false, &filter); err != nil {
		return nil, err
	}
	return filter, nil
}

func (f *httpHandler) respJson(w http.ResponseWriter, v interface{}) {
	p, err := json.Marshal(v)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", network.HTTPContentTypeJson)
	w.WriteHeader(http.StatusOK)
	_, _ = w.Write(p)
}

func (f *httpHandler) respJsonErr(w http.ResponseWriter, err error, code int) {
	w.Header().Set("Content-Type", network.HTTPContentTypeJson)
	w.WriteHeader(code)
	_, _ = w.Write([]byte(fmt.Sprintf(`{"result":"%s"}`, err)))
}