modelRT/handler/measurement_recommend.go

// Package handler provides HTTP handlers for various endpoints.
package handler

import (
	"net/http"

	"modelRT/logger"
	"modelRT/model"
	"modelRT/network"

	"github.com/gin-gonic/gin"
)

// MeasurementRecommendHandler define measurement recommend API
// MeasurementRecommendHandler define measurement recommend API
// @Summary 测量点推荐（搜索框自动补全）
// @Description 根据用户输入的字符串，从 Redis 中查询可能的测量点或结构路径，并提供推荐列表。
// @Tags Recommend
// @Accept json
// @Produce json
// @Param request body network.MeasurementRecommendRequest true "查询输入参数，例如 'trans' 或 'grid_key.'"
// @Success 200 {object} network.SuccessResponse{payload=network.MeasurementRecommendPayload} "成功返回推荐列表"
// @Failure 200 {object} network.FailureResponse "请求或查询失败。**注意**：HTTP 状态码始终为 200，但内部 Code 为 400 (参数错误) 或 500 (内部错误)。"
// @Router /api/v1/recommend/measurement [post]
func MeasurementRecommendHandler(c *gin.Context) {
	var request network.MeasurementRecommendRequest

	if err := c.ShouldBindJSON(&request); err != nil {
		logger.Error(c, "failed to unmarshal measurement recommend request", "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusBadRequest,
			Msg:  err.Error(),
		})
		return
	}

	recommends, isFuzzy, err := model.RedisSearchRecommend(c, request.Input)
	if err != nil {
		logger.Error(c, "failed to get recommend data from redis", "input", request.Input, "error", err)
		c.JSON(http.StatusOK, network.FailureResponse{
			Code: http.StatusInternalServerError,
			Msg:  err.Error(),
			PayLoad: map[string]any{
				"input": request.Input,
			},
		})
		return
	}

	var finalOffset int
	if isFuzzy {
		var maxOffset int
		for index, recommend := range recommends {
			offset := model.GetLongestCommonPrefixLength(request.Input, recommend)
			if index == 0 || offset > maxOffset {
				maxOffset = offset
			}
		}
		finalOffset = maxOffset
	} else {
		var minOffset int
		for index, recommend := range recommends {
			offset := model.GetLongestCommonPrefixLength(request.Input, recommend)
			if index == 0 || offset < minOffset {
				minOffset = offset
			}
		}
		finalOffset = minOffset
	}

	resultRecommends := make([]string, 0, len(recommends))
	seen := make(map[string]struct{})

	for _, recommend := range recommends {
		recommendTerm := recommend[finalOffset:]
		if len(recommendTerm) != 0 {
			if _, exists := seen[recommendTerm]; !exists {
				seen[recommendTerm] = struct{}{}
				resultRecommends = append(resultRecommends, recommendTerm)
			}
		}
	}

	c.JSON(http.StatusOK, network.SuccessResponse{
		Code: http.StatusOK,
		Msg:  "success",
		PayLoad: map[string]any{
			"input":            request.Input,
			"offset":           finalOffset,
			"recommended_list": resultRecommends,
		},
	})
}