bj_power/bj_power_mes/internal/handler/line.go

package handler

import (
	"net/http"
	"strings"

	"bj_power_mes/common/httpx"
	"bj_power_mes/internal/logic"
	"bj_power_mes/internal/svc"
)

// OccupyPointHandler POST /line/occupy（点位人工记账：IN 上料占位 / OUT 下料释放）
// 供工位终端在无 PLC 联调时、或上料位(IN)/末端下料检测位(11/12) 人工操作时维护点位台账（唯一事实源）。
func OccupyPointHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var req struct {
			PointNo  string `json:"pointNo"`
			Sn       string `json:"sn"`
			OrderNo  string `json:"orderNo"`
			Operator string `json:"operator"`
			Action   string `json:"action"` // IN=上料 / OUT=下料
		}
		if err := httpx.ParseJSON(r, &req); err != nil {
			httpx.BadRequest(w, "请求体解析失败")
			return
		}
		action := strings.ToUpper(strings.TrimSpace(req.Action))
		if action == "" {
			action = "IN"
		}
		if action != "IN" && action != "OUT" {
			httpx.BadRequest(w, "action 仅支持 IN(上料) / OUT(下料)")
			return
		}
		op := req.Operator
		if op == "" {
			op = operator(r, "")
		}
		if err := logic.New(svcCtx).OccupyPoint(r.Context(), req.PointNo, req.Sn, req.OrderNo, op, action); err != nil {
			httpx.Fail(w, 2407, err.Error())
			return
		}
		msg := "上料已记账"
		if action == "OUT" {
			msg = "下料已释放"
		}
		httpx.OkMessage(w, msg, nil)
	}
}

// ListPointsHandler GET /line/points（产线点位台账：上料位/工位/缓存位/接驳台/末端 当前工件）
func ListPointsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		_ = logic.New(svcCtx).InitLinePoints(r.Context())
		data, err := logic.New(svcCtx).ListPoints(r.Context())
		if err != nil {
			httpx.Fail(w, 2401, err.Error())
			return
		}
		httpx.Ok(w, data)
	}
}

// IssueMoveHandler POST /line/move（上位机下发移料指令：起点位 → 目标点位）
func IssueMoveHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var req struct {
			Sn        string `json:"sn"`
			FromPoint string `json:"fromPoint"`
			ToPoint   string `json:"toPoint"`
			OrderNo   string `json:"orderNo"`
		}
		if err := httpx.ParseJSON(r, &req); err != nil {
			httpx.BadRequest(w, "请求体解析失败")
			return
		}
		data, err := logic.New(svcCtx).IssueMove(r.Context(), req.Sn, req.FromPoint, req.ToPoint, req.OrderNo, operator(r, ""))
		if err != nil {
			httpx.Fail(w, 2402, err.Error())
			return
		}
		httpx.OkMessage(w, "移料指令已下发", data)
	}
}

// AckMoveHandler POST /line/move/ack（PLC 应答）
func AckMoveHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var req struct {
			CmdNo string `json:"cmdNo"`
		}
		if err := httpx.ParseJSON(r, &req); err != nil {
			httpx.BadRequest(w, "请求体解析失败")
			return
		}
		if err := logic.New(svcCtx).AckMove(r.Context(), req.CmdNo); err != nil {
			httpx.Fail(w, 2403, err.Error())
			return
		}
		httpx.OkMessage(w, "已应答", nil)
	}
}

// ArriveMoveHandler POST /line/move/arrive（工件到位：回写台账并闭环指令）
func ArriveMoveHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var req struct {
			CmdNo string `json:"cmdNo"`
		}
		if err := httpx.ParseJSON(r, &req); err != nil {
			httpx.BadRequest(w, "请求体解析失败")
			return
		}
		if err := logic.New(svcCtx).ArriveMove(r.Context(), req.CmdNo); err != nil {
			httpx.Fail(w, 2404, err.Error())
			return
		}
		httpx.OkMessage(w, "到位已记账", nil)
	}
}

// ListMoveCmdsHandler GET /line/moves?status=&sn=&limit=
func ListMoveCmdsHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		q := r.URL.Query()
		data, err := logic.New(svcCtx).ListMoveCmds(r.Context(), q.Get("status"), q.Get("sn"),
			atoiDefault(q.Get("limit"), 50))
		if err != nil {
			httpx.Fail(w, 2405, err.Error())
			return
		}
		httpx.Ok(w, data)
	}
}

// CallMaterialHandler POST /line/call-material（工位终端叫料：选接驳台）
func CallMaterialHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var req struct {
			StationNo int                      `json:"stationNo"`
			Dock      string                   `json:"dock"`
			OrderNo   string                   `json:"orderNo"`
			Items     []logic.CallMaterialItem `json:"items"`
		}
		if err := httpx.ParseJSON(r, &req); err != nil {
			httpx.BadRequest(w, "请求体解析失败")
			return
		}
		n, err := logic.New(svcCtx).CallMaterial(r.Context(), req.StationNo, req.Dock, req.OrderNo, operator(r, ""), req.Items)
		if err != nil {
			httpx.Fail(w, 2406, err.Error())
			return
		}
		httpx.OkMessage(w, "叫料已提交", map[string]any{"count": n})
	}
}