backend-go/controllers/product_traces_controller.go

package controllers

import (
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"

	"git.beifan.cn/trace-system/backend-go/models"
	"git.beifan.cn/trace-system/backend-go/services"
)

// ProductTracesController 产品溯源控制器
type ProductTracesController struct {
	productTracesService services.ProductTracesService
}

// NewProductTracesController 创建产品溯源控制器实例
func NewProductTracesController() *ProductTracesController {
	return &ProductTracesController{
		productTracesService: services.ProductTracesService{},
	}
}

// Create 创建产品溯源
func (c *ProductTracesController) Create(ctx *gin.Context) {
	userModel, ok := GetCurrentUser(ctx)
	if !ok {
		return
	}

	var dto models.CreateProductTraceDTO
	if !BindJSON(ctx, &dto) {
		return
	}

	trace, err := c.productTracesService.Create(dto, userModel.ID)
	if err != nil {
		ErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	SuccessResponse(ctx, "产品溯源创建成功", gin.H{
		"trace": trace,
	})
}

// FindAll 获取产品溯源列表
func (c *ProductTracesController) FindAll(ctx *gin.Context) {
	page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
	limit, _ := strconv.Atoi(ctx.DefaultQuery("limit", "20"))
	search := ctx.DefaultQuery("search", "")

	traces, total, totalPages, err := c.productTracesService.FindAll(page, limit, search)
	if err != nil {
		ErrorResponse(ctx, http.StatusInternalServerError, err.Error())
		return
	}

	SuccessResponse(ctx, "获取产品溯源列表成功", gin.H{
		"data": traces,
		"pagination": gin.H{
			"page":       page,
			"limit":      limit,
			"total":      total,
			"totalPages": totalPages,
		},
	})
}

// FindOne 获取产品溯源详情
func (c *ProductTracesController) FindOne(ctx *gin.Context) {
	serialNumber := ctx.Param("serialNumber")

	trace, err := c.productTracesService.FindOne(serialNumber)
	if err != nil {
		ErrorResponse(ctx, http.StatusNotFound, err.Error())
		return
	}

	SuccessResponse(ctx, "查询成功", gin.H{
		"trace": trace,
	})
}

// Update 更新产品溯源
func (c *ProductTracesController) Update(ctx *gin.Context) {
	serialNumber := ctx.Param("serialNumber")
	var dto models.UpdateProductTraceDTO
	if !BindJSON(ctx, &dto) {
		return
	}

	trace, err := c.productTracesService.Update(serialNumber, dto)
	if err != nil {
		ErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	SuccessResponse(ctx, "产品溯源更新成功", gin.H{
		"trace": trace,
	})
}

// PublicQuery 公开查询产品溯源
func (c *ProductTracesController) PublicQuery(ctx *gin.Context) {
	serialNumber := ctx.Param("serialNumber")

	trace, err := c.productTracesService.PublicQuery(serialNumber)
	if err != nil {
		ErrorResponse(ctx, http.StatusNotFound, err.Error())
		return
	}

	SuccessResponse(ctx, "查询成功", gin.H{
		"trace": trace,
	})
}

// GenerateQRCode 生成产品溯源二维码
func (c *ProductTracesController) GenerateQRCode(ctx *gin.Context) {
	serialNumber := ctx.Param("serialNumber")

	var qrCodeData models.QRCodeDTO
	if !BindJSON(ctx, &qrCodeData) {
		return
	}

	protocol := "http"
	if ctx.Request.TLS != nil {
		protocol = "https"
	}

	qrCodeBase64, queryURL, err := c.productTracesService.GenerateQRCode(
		serialNumber,
		qrCodeData.BaseUrl,
		ctx.Request.Host,
		protocol,
	)
	if err != nil {
		ErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	SuccessResponse(ctx, "二维码生成成功", gin.H{
		"qrCodeData": qrCodeBase64,
		"queryUrl":   queryURL,
	})
}

// UploadWechatQRCode 上传公众号二维码
func (c *ProductTracesController) UploadWechatQRCode(ctx *gin.Context) {
	serialNumber := ctx.Param("serialNumber")

	fileHeader, err := ctx.FormFile("file")
	if err != nil {
		ErrorResponse(ctx, http.StatusBadRequest, "请选择公众号二维码图片")
		return
	}

	trace, err := c.productTracesService.UploadWechatQRCode(serialNumber, fileHeader)
	if err != nil {
		ErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	SuccessResponse(ctx, "公众号二维码上传成功", gin.H{
		"trace": trace,
	})
}

// Revoke 停用产品溯源
func (c *ProductTracesController) Revoke(ctx *gin.Context) {
	serialNumber := ctx.Param("serialNumber")

	trace, err := c.productTracesService.Revoke(serialNumber)
	if err != nil {
		ErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	SuccessResponse(ctx, "产品溯源已停用", gin.H{
		"trace": trace,
	})
}

// Delete 删除产品溯源
func (c *ProductTracesController) Delete(ctx *gin.Context) {
	serialNumber := ctx.Param("serialNumber")

	if err := c.productTracesService.Delete(serialNumber); err != nil {
		ErrorResponse(ctx, http.StatusBadRequest, err.Error())
		return
	}

	SuccessResponse(ctx, "产品溯源删除成功")
}