jiu/backend/internal/handler/partner.go

package handler

import (
	"fmt"
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
	"gorm.io/gorm"

	"github.com/wangjia/jiu/backend/internal/middleware"
	"github.com/wangjia/jiu/backend/internal/model"
	"github.com/wangjia/jiu/backend/internal/util"
)

type PartnerHandler struct {
	db *gorm.DB
}

func NewPartnerHandler(db *gorm.DB) *PartnerHandler {
	return &PartnerHandler{db: db}
}

func (h *PartnerHandler) List(c *gin.Context) {
	shopID := middleware.GetShopID(c)
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))
	pageSize = util.ValidatePageSize(pageSize, 20, 200)

	query := h.db.Model(&model.Partner{}).
		Where("shop_id = ? AND deleted_at IS NULL", shopID)

	if t := c.Query("type"); t != "" {
		query = query.Where("FIND_IN_SET(?, type)", t)
	}
	if kw := c.Query("keyword"); kw != "" {
		query = query.Where("name LIKE ? OR phone LIKE ?", "%"+kw+"%", "%"+kw+"%")
	}

	var total int64
	query.Count(&total)

	partners := make([]model.Partner, 0)
	query.Offset((page - 1) * pageSize).Limit(pageSize).Order("id DESC").Find(&partners)

	c.JSON(http.StatusOK, gin.H{"data": partners, "total": total, "page": page, "page_size": pageSize})
}

func (h *PartnerHandler) Create(c *gin.Context) {
	shopID := middleware.GetShopID(c)
	var p model.Partner
	if err := c.ShouldBindJSON(&p); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	p.ShopID = shopID
	// 编码未提供时自动生成：供应商 S001/S002…，客户 C001/C002…
	if p.Code == "" {
		prefix := "S"
		if p.Type == "customer" {
			prefix = "C"
		}
		var count int64
		h.db.Model(&model.Partner{}).
			Where("shop_id = ? AND type = ? AND deleted_at IS NULL", shopID, p.Type).
			Count(&count)
		p.Code = fmt.Sprintf("%s%03d", prefix, count+1)
	}
	if err := h.db.Create(&p).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	util.RespondCreated(c, p)
}

func (h *PartnerHandler) Update(c *gin.Context) {
	shopID := middleware.GetShopID(c)
	var p model.Partner
	if err := h.db.Where("id = ? AND shop_id = ? AND deleted_at IS NULL", c.Param("id"), shopID).
		First(&p).Error; err != nil {
		c.JSON(http.StatusNotFound, gin.H{"error": "not found"})
		return
	}
	var req struct {
		Name        string  `json:"name"`
		Type        string  `json:"type"`
		Code        string  `json:"code"`
		Contact     string  `json:"contact"`
		Phone       string  `json:"phone"`
		Address     string  `json:"address"`
		BankAccount string  `json:"bank_account"`
		CreditLimit float64 `json:"credit_limit"`
		Status      string  `json:"status"`
		Remark      string  `json:"remark"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}
	if err := h.db.Model(&p).Where("shop_id = ?", shopID).Updates(map[string]interface{}{
		"name":         req.Name,
		"type":         req.Type,
		"code":         req.Code,
		"contact":      req.Contact,
		"phone":        req.Phone,
		"address":      req.Address,
		"bank_account": req.BankAccount,
		"credit_limit": req.CreditLimit,
		"status":       req.Status,
		"remark":       req.Remark,
	}).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
		return
	}
	h.db.Where("id = ? AND shop_id = ?", p.ID, shopID).First(&p)
	util.RespondSuccess(c, p)
}

func (h *PartnerHandler) Delete(c *gin.Context) {
	shopID := middleware.GetShopID(c)
	now := timeNow()
	result := h.db.Model(&model.Partner{}).
		Where("id = ? AND shop_id = ? AND deleted_at IS NULL", c.Param("id"), shopID).
		Update("deleted_at", now)
	if result.RowsAffected == 0 {
		c.JSON(http.StatusNotFound, gin.H{"error": "not found"})
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": "deleted"})
}