pss/app/api.go

package app

import (
	"encoding/json"
	"errors"
	"io"
	"log"
	"net/http"
	"pss/app/midleware/auth"
	"pss/mod/user"
	"pss/mod/warehouse"
)

func ApiHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Access-Control-Allow-Origin", "*")
	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
	w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")

	if r.Method != http.MethodPost {
		writeErr(w, r.Method, errors.New("only allow POST"))
		return
	}
	b, err := io.ReadAll(r.Body)
	if err != nil {
		writeErr(w, r.Method, err)
		return
	}
	param := string(b)
	req := Request{}
	if err = json.Unmarshal([]byte(param), &req); err != nil {
		writeErr(w, r.Method, err)
		return
	}
	u, err := loginValid(r, req)
	//if err != nil {
	//	writeErr(w, r.Method, errors.New("用户未登录"))
	//	return
	//}

	switch req.Method {
	case Login:
		login(w, &req)
	case Logout:
		logout(w, r)
	case GetSmsCode:
		getSmsCode(w, &req)
	case RegisterUser:
		registerUser(w, &req)
	case GetUser:
		getUser(w, &req, u)
	case FetchWarehouse:
		fetchWarehouse(w, &req, u)
	case GetWarehouse:
		getWarehouse(w, &req, u)
	case SaveWarehouse:
		saveWarehouse(w, &req, u)
	case DeleteWarehouse:
		deleteWarehouse(w, &req, u)
	case SaveMap:
		saveMap(w, &req, u)
	case SaveMapConfig:
		saveMapConfig(w, &req, u)
	case GetMap:
		getMap(w, &req, u)
	case GetMapConfig:
		getMapConfig(w, &req)
	case ExportMap:
		export(w, r, &req, u)
	case SaveAngle:
		saveAngle(w, &req, u)
	case ExportMapConfig:
		exportConfig(w, r, &req, u)
	case FetchMaterials:
		fetchMaterials(w, &req)
	case GetMaterial:
		getMaterial(w, &req)
	case FetchMaterialSpec:
		fetchMaterialSpec(w, &req)
	case GetMaterialSpec:
		getMaterialSpec(w, &req)
	case SaveSpec:
		saveSpec(w, &req, u)
	case DeleteSpec:
		deleteSpec(w, &req)
	case FetchMaterialDetail:
		fetchMaterialDetail(w, &req)
	case SaveMaterialDetail:
		saveMaterialDetail(w, &req)
	case GetMaterialDetail:
		getMaterialDetail(w, &req)
	case DeleteMaterialDetail:
		deleteMaterialDetail(w, &req)
	case DownloadMaterialDetail:
		downloadMaterialDetail(w, &req)
	case FetchMaterialCost:
		fetchMaterialCost(w, &req)
	case SaveMaterialCost:
		saveMaterialCost(w, &req)
	case GetDeviceCategory:
		getDeviceCategory(w, &req)
	case GetDeviceList:
		getDeviceList(w, &req)
	case GetDeviceListParam:
		getDeviceListParam(w, &req)
	case SaveDevice:
		saveDevice(w, &req)
	case InitSortDevice:
		initSortDevice(w, &req)
	case SortDevice:
		sortDevice(w, &req)
	case ChangeDeviceState:
		changeDeviceState(w, &req)
	case DeleteDevice:
		deleteDevice(w, &req)
	case FetchDeviceType:
		fetchDeviceType(w, &req)
	case FetchQuote:
		fetchQuote(w, &req)
	case SaveQuote:
		saveQuote(w, &req)
	case DeleteQuote:
		deleteQuote(w, &req)
	case SortQuote:
		sortQuote(w, &req)
	case DownloadQuote:
		downloadQuote(w, &req)
	case SaveQuoteDesc:
		saveQuoteDesc(w, &req)
	default:
		writeErr(w, r.Method, errors.New("404 error"))
	}
}

type Request struct {
	Method string         `json:"method"`
	Param  map[string]any `json:"param"`
}

type respBody struct {
	Method string `json:"method"`
	Ret    string `json:"ret"`
	Msg    string `json:"msg"`
	Data   any    `json:"data"`
}

type API struct{}

func writeOK(w http.ResponseWriter, method string, d any) {
	var r respBody
	r.Method = method
	r.Ret = "ok"
	r.Data = d
	resp, _ := json.Marshal(r)
	w.Header().Set("Content-Type", "application/json")
	w.Write(resp)
}

func writeErr(w http.ResponseWriter, method string, err error) {
	log.Printf("method:%s,err:%v", method, err)
	var r respBody
	r.Method = method
	r.Ret = "failed"
	r.Msg = err.Error()
	resp, _ := json.Marshal(r)
	w.Header().Set("Content-Type", "application/json")
	w.Write(resp)
}

func loginValid(r *http.Request, req Request) (user.User, error) {
	if req.Method == Login || req.Method == GetSmsCode || req.Method == RegisterUser || req.Method == InitSortDevice {
		return user.User{}, nil
	}
	return auth.GetUser(r)
}

func authCheck(w http.ResponseWriter, r *Request, wid int, u user.User) bool {
	if u.Role == user.Admin {
		return true
	}
	wh, err := warehouse.Get(wid)
	if err != nil {
		writeErr(w, r.Method, err)
		return false
	}
	if wh.Creator != u.Name {
		writeErr(w, r.Method, errors.New("越权访问"))
		return false
	}
	return true
}