lucky_bot/magic_server/apis/admin/node_info.go

package admin

import (
	"app/commons/constant"
	"app/commons/model/entity"
	"app/commons/services"
	"github.com/gin-gonic/gin"
	"github.com/shopspring/decimal"
)

// CreateNodeInfo 创建节点产品
func (s *Server) CreateNodeInfo(ctx *gin.Context) {
	c := s.FromContext(ctx)
	type Request struct {
		NodeName              string          `json:"nodeName" binding:"required"`
		SupportPaymentSymbols string          `json:"supportPaymentSymbols"`
		UsdPrice              decimal.Decimal `json:"usdPrice"`
		SoldQuantity          decimal.Decimal `json:"soldQuantity"`
		UpperQuantityLimit    decimal.Decimal `json:"upperQuantityLimit"`
		LimitTime             int64           `json:"limitTime"`
		Sort                  int             `json:"sort"`
		Enable                bool            `json:"enable"`
	}
	req := new(Request)
	if err := c.ShouldBindJSON(&req); err != nil {
		c.Fail(constant.ErrorParams)
		return
	}

	nodeInfo := &entity.NodeInfo{
		NodeName:              req.NodeName,
		SupportPaymentSymbols: req.SupportPaymentSymbols,
		UsdPrice:              req.UsdPrice,
		SoldQuantity:          req.SoldQuantity,
		UpperQuantityLimit:    req.UpperQuantityLimit,
		LimitTime:             req.LimitTime,
		Sort:                  req.Sort,
		Enable:                req.Enable,
	}

	if err := s.DB().Create(nodeInfo).Error; err != nil {
		c.Fail(err.Error())
		return
	}

	c.Resp(nodeInfo)
}

// UpdateNodeInfo 更新节点产品
func (s *Server) UpdateNodeInfo(ctx *gin.Context) {
	c := s.FromContext(ctx)
	type Request struct {
		Id                    int64            `json:"id" binding:"required"`
		NodeName              *string          `json:"nodeName"`
		SupportPaymentSymbols *string          `json:"supportPaymentSymbols"`
		UsdPrice              *decimal.Decimal `json:"usdPrice"`
		SoldQuantity          *decimal.Decimal `json:"soldQuantity"`
		UpperQuantityLimit    *decimal.Decimal `json:"upperQuantityLimit"`
		LimitTime             *int64           `json:"limitTime"`
		Sort                  *int             `json:"sort"`
		Enable                *bool            `json:"enable"`
	}
	req := new(Request)
	if err := c.ShouldBindJSON(&req); err != nil {
		c.Fail(constant.ErrorParams)
		return
	}

	nodeInfo := &entity.NodeInfo{}
	if err := s.DB().First(nodeInfo, req.Id).Error; err != nil {
		c.Fail(constant.ErrorInfo)
		return
	}

	updates := make(map[string]interface{})
	if req.NodeName != nil {
		updates["node_name"] = *req.NodeName
	}
	if req.SupportPaymentSymbols != nil {
		updates["support_payment_symbols"] = *req.SupportPaymentSymbols
	}
	if req.UsdPrice != nil {
		updates["usd_price"] = *req.UsdPrice
	}
	if req.SoldQuantity != nil {
		updates["sold_quantity"] = *req.SoldQuantity
	}
	if req.UpperQuantityLimit != nil {
		updates["upper_quantity_limit"] = *req.UpperQuantityLimit
	}
	if req.LimitTime != nil {
		updates["limit_time"] = *req.LimitTime
	}
	if req.Sort != nil {
		updates["sort"] = *req.Sort
	}
	if req.Enable != nil {
		updates["enable"] = *req.Enable
	}

	if err := s.DB().Model(nodeInfo).Updates(updates).Error; err != nil {
		c.Fail(err.Error())
		return
	}

	c.Resp(nodeInfo)
}

// DeleteNodeInfo 删除节点产品
func (s *Server) DeleteNodeInfo(ctx *gin.Context) {
	c := s.FromContext(ctx)
	type Request struct {
		Id int64 `json:"id" binding:"required"`
	}
	req := new(Request)
	if err := c.ShouldBindJSON(&req); err != nil {
		c.Fail(constant.ErrorParams)
		return
	}

	if err := s.DB().Delete(&entity.NodeInfo{}, req.Id).Error; err != nil {
		c.Fail(err.Error())
		return
	}

	c.Resp(nil)
}

// GetNodeInfo 获取节点产品详情
func (s *Server) GetNodeInfo(ctx *gin.Context) {
	c := s.FromContext(ctx)
	type Request struct {
		Id int64 `json:"id" form:"id" binding:"required"`
	}
	req := new(Request)
	if err := c.ShouldBind(&req); err != nil {
		c.Fail(constant.ErrorParams)
		return
	}

	nodeInfo := &entity.NodeInfo{}
	if err := s.DB().First(nodeInfo, req.Id).Error; err != nil {
		c.Fail(constant.ErrorInfo)
		return
	}

	c.Resp(nodeInfo)
}

// FindNodeInfo 分页查询节点产品
func (s *Server) FindNodeInfo(ctx *gin.Context) {
	c := s.FromContext(ctx)
	type Request struct {
		services.Pagination
		NodeName  string `json:"nodeName" form:"nodeName"`
		Enable    *bool  `json:"enable" form:"enable"`
		BeginTime int64  `json:"beginTime" form:"beginTime"`
		EndTime   int64  `json:"endTime" form:"endTime"`
		Order     string `json:"order" form:"order"`
		IsExport  bool   `json:"isExport" form:"isExport"`
		Fields    string `json:"fields" form:"fields"`
	}
	req := new(Request)
	if err := c.ShouldBind(&req); err != nil {
		c.Fail(constant.ErrorParams)
		return
	}

	db := s.DB().Model(&entity.NodeInfo{})

	// 条件查询
	if req.NodeName != "" {
		db = db.Where("node_name LIKE ?", "%"+req.NodeName+"%")
	}
	if req.Enable != nil {
		db = db.Where("enable = ?", *req.Enable)
	}
	if req.BeginTime > 0 {
		db = db.Where("created_at >= ?", req.BeginTime)
	}
	if req.EndTime > 0 {
		db = db.Where("created_at <= ?", req.EndTime)
	}

	// 排序
	if req.Order == "" {
		req.Order = "id desc"
	}
	db = db.Order(req.Order)

	// 分页查询
	list, err := s.PageNodeInfo(db, &req.Pagination)
	if err != nil {
		c.Fail(err.Error())
		return
	}

	// 返回映射
	enableMap := map[bool]string{
		true:  "开放购买",
		false: "未开放",
	}

	// 可导出字段列表
	cols := []map[string]string{
		{"field": "id", "label": "ID"},
		{"field": "nodeName", "label": "节点名称"},
		{"field": "supportPaymentSymbols", "label": "支持支付币种"},
		{"field": "usdPrice", "label": "单价(USD)"},
		{"field": "soldQuantity", "label": "已售数量"},
		{"field": "upperQuantityLimit", "label": "可售上限"},
		{"field": "limitTime", "label": "结束时间"},
		{"field": "sort", "label": "排序"},
		{"field": "enable", "label": "状态"},
		{"field": "createdAt", "label": "创建时间"},
	}

	c.Resp(gin.H{
		"list":       list,
		"pagination": req.Pagination,
		"enableMap":  enableMap,
		"cols":       cols,
	})
}