app-api/internal/handler/share_code.go

package handler

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

	"github.com/gin-gonic/gin"
	"github.com/luxsin/app-api/internal/cache"
	"github.com/luxsin/app-api/pkg/encode"
	"go.uber.org/zap"
)

type ShareCodeHandler struct {
	cache *cache.ShareCodeCache
	log   *zap.Logger
}

func NewShareCodeHandler(shareCache *cache.ShareCodeCache, log *zap.Logger) *ShareCodeHandler {
	return &ShareCodeHandler{cache: shareCache, log: log}
}

// ExportShareCode 导出分享码
//
//	@Summary		创建 EQ 分享码
//	@Description	将用户的 EQ 数据生成一个 5 位分享码，有效期 30 分钟
//	@Tags			ShareCode
//	@Accept			json
//	@Produce		json
//	@Param			body	body		object{mac=string,eq_data=object}	true	"分享请求"
//	@Success		200		{object}	map[string]any						"成功返回 share_code、expire_at、eq_data"
//	@Failure		400		{object}	map[string]any						"参数校验失败"
//	@Failure		500		{object}	map[string]any						"系统错误"
//	@Router			/audio/shareCreate [post]
//
// POST /audio/shareCreate
// Body: {"mac": "xx", "eq_data": {...}}
func (h *ShareCodeHandler) ExportShareCode(c *gin.Context) {
	var req struct {
		Mac    string          `json:"mac"`
		EqData json.RawMessage `json:"eq_data"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusOK, gin.H{
			"code": 400,
			"msg":  "参数校验失败",
		})
		return
	}

	mac := strings.TrimSpace(req.Mac)
	eqDataRaw := strings.TrimSpace(string(req.EqData))
	clientIP := encode.ClientPublicIP(c)

	if mac == "" || eqDataRaw == "" {
		c.JSON(http.StatusOK, gin.H{
			"code": 400,
			"msg":  "参数校验失败",
		})
		return
	}

	if !json.Valid([]byte(eqDataRaw)) {
		c.JSON(http.StatusOK, gin.H{
			"code": 400,
			"msg":  "eq_data 格式错误",
		})
		return
	}

	ctx := c.Request.Context()
	data, err := h.cache.Create(ctx, mac, clientIP, []byte(eqDataRaw))
	if err != nil {
		h.log.Error("create share code failed", zap.Error(err))
		c.JSON(http.StatusOK, gin.H{
			"code": 500,
			"msg":  "系统错误",
		})
		return
	}

	var eqData any
	if err := json.Unmarshal([]byte(data.EqData), &eqData); err != nil {
		eqData = data.EqData
	}

	c.JSON(http.StatusOK, gin.H{
		"code":       200,
		"msg":        "操作成功",
		"share_code": data.ShareCode,
		"expire_at":  data.ExpireAt.Format("2006-01-02 15:04:05"),
		"eq_data":    eqData,
	})
}

// ListShareCodesByMac 查询某 MAC 尚未过期的分享码
//
//	@Summary		查询未过期分享码
//	@Description	根据设备 MAC 地址查询该设备尚未过期的所有分享码（仅查询 Redis，依赖 TTL 自动过期）
//	@Tags			ShareCode
//	@Produce		json
//	@Param			mac	query		string			true	"设备 MAC 地址"
//	@Success		200	{object}	map[string]any	"成功返回 share_codes 列表"
//	@Failure		400	{object}	map[string]any	"参数校验失败"
//	@Failure		500	{object}	map[string]any	"系统错误"
//	@Router			/audio/shareList [get]
func (h *ShareCodeHandler) ListShareCodesByMac(c *gin.Context) {
	mac := strings.TrimSpace(c.Query("mac"))
	if mac == "" {
		c.JSON(http.StatusOK, gin.H{"code": 400, "msg": "参数校验失败"})
		return
	}

	ctx := c.Request.Context()

	items, err := h.cache.ListByMac(ctx, mac)
	if err != nil {
		h.log.Error("list share codes by mac failed", zap.String("mac", mac), zap.Error(err))
		c.JSON(http.StatusOK, gin.H{"code": 500, "msg": "系统错误"})
		return
	}

	type shareItem struct {
		ShareCode string `json:"share_code"`
		ExpireAt  string `json:"expire_at"`
		EqData    any    `json:"eq_data"`
	}
	list := make([]shareItem, 0, len(items))
	for _, item := range items {
		var eqData any
		if err := json.Unmarshal([]byte(item.EqData), &eqData); err != nil {
			eqData = item.EqData
		}
		list = append(list, shareItem{
			ShareCode: item.ShareCode,
			ExpireAt:  item.ExpireAt.Format("2006-01-02 15:04:05"),
			EqData:    eqData,
		})
	}

	c.JSON(http.StatusOK, gin.H{
		"code":        200,
		"msg":         "操作成功",
		"share_codes": list,
	})
}

// ImportShareCode 导入分享码
//
//	@Summary		导入 EQ 分享码
//	@Description	根据分享码获取他人分享的 EQ 数据
//	@Tags			ShareCode
//	@Produce		json
//	@Param			mac			query		string			true	"设备 MAC 地址"
//	@Param			shareCode	query		string			true	"5 位分享码"
//	@Success		200			{object}	map[string]any	"成功返回 eq_data"
//	@Failure		400			{object}	map[string]any	"参数校验失败"
//	@Failure		500			{object}	map[string]any	"系统错误"
//	@Router			/audio/shareAccept [get]
//
// GET /audio/shareAccept?mac=xx&shareCode=ABC12
func (h *ShareCodeHandler) ImportShareCode(c *gin.Context) {
	mac := strings.TrimSpace(c.Query("mac"))
	shareCode := strings.TrimSpace(c.Query("shareCode"))
	clientIP := encode.ClientPublicIP(c)

	if mac == "" || shareCode == "" {
		c.JSON(http.StatusOK, gin.H{
			"code": 400,
			"msg":  "参数校验失败",
		})
		return
	}
	if len(shareCode) != 5 {
		c.JSON(http.StatusOK, gin.H{
			"code": 0,
			"msg":  "分享码无效或已过期",
		})
		return
	}

	ctx := c.Request.Context()
	data, err := h.cache.Get(ctx, shareCode)
	if err != nil {
		h.log.Error("get share code failed", zap.String("share_code", shareCode), zap.Error(err))
		c.JSON(http.StatusOK, gin.H{
			"code": 500,
			"msg":  "系统错误",
		})
		return
	}
	if data == nil {
		c.JSON(http.StatusOK, gin.H{
			"code": 0,
			"msg":  "分享码无效或已过期",
		})
		return
	}

	if err := h.cache.EnqueueImportLog(ctx, mac, shareCode, clientIP, data.EqData, data.ExpireAt); err != nil {
		h.log.Error("enqueue share import log failed",
			zap.String("share_code", shareCode),
			zap.Error(err),
		)
		c.JSON(http.StatusOK, gin.H{
			"code": 500,
			"msg":  "系统错误",
		})
		return
	}

	var eqData any
	if err := json.Unmarshal([]byte(data.EqData), &eqData); err != nil {
		eqData = data.EqData
	}

	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"msg":     "操作成功",
		"eq_data": eqData,
	})
}