magic_server/apis/admin/node_order_payments.go

package admin

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

// CreateNodeOrderPayments 创建订单支付信息
func (s *Server) CreateNodeOrderPayments(ctx *gin.Context) {
	c := s.FromContext(ctx)
	type Request struct {
		NodeOrderRecordId string          `json:"nodeOrderRecordId" binding:"required"`
		UserId            int64           `json:"userId" binding:"required"`
		Uid               string          `json:"uid" binding:"required"`
		OrderUsdAmount    decimal.Decimal `json:"orderUsdAmount"`
		PaySymbol         decimal.Decimal `json:"paySymbol"`
		PaySymbolUsdPrice decimal.Decimal `json:"paySymbolUsdPrice"`
		PayQuantity       decimal.Decimal `json:"payQuantity"`
		PayUsdAmount      decimal.Decimal `json:"payUsdAmount"`
	}
	req := new(Request)
	if err := c.ShouldBindJSON(&req); err != nil {
		c.Fail(constant.ErrorParams)
		return
	}

	payment := &entity.NodeOrderPayments{
		NodeOrderRecordId: req.NodeOrderRecordId,
		UserId:            req.UserId,
		Uid:               req.Uid,
		OrderUsdAmount:    req.OrderUsdAmount,
		PaySymbol:         req.PaySymbol,
		PaySymbolUsdPrice: req.PaySymbolUsdPrice,
		PayQuantity:       req.PayQuantity,
		PayUsdAmount:      req.PayUsdAmount,
	}

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

	c.Resp(payment)
}

// UpdateNodeOrderPayments 更新订单支付信息
func (s *Server) UpdateNodeOrderPayments(ctx *gin.Context) {
	c := s.FromContext(ctx)
	type Request struct {
		Id                int64            `json:"id" binding:"required"`
		NodeOrderRecordId *string          `json:"nodeOrderRecordId"`
		UserId            *int64           `json:"userId"`
		Uid               *string          `json:"uid"`
		OrderUsdAmount    *decimal.Decimal `json:"orderUsdAmount"`
		PaySymbol         *decimal.Decimal `json:"paySymbol"`
		PaySymbolUsdPrice *decimal.Decimal `json:"paySymbolUsdPrice"`
		PayQuantity       *decimal.Decimal `json:"payQuantity"`
		PayUsdAmount      *decimal.Decimal `json:"payUsdAmount"`
	}
	req := new(Request)
	if err := c.ShouldBindJSON(&req); err != nil {
		c.Fail(constant.ErrorParams)
		return
	}

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

	updates := make(map[string]interface{})
	if req.NodeOrderRecordId != nil {
		updates["node_order_record_id"] = *req.NodeOrderRecordId
	}
	if req.UserId != nil {
		updates["user_id"] = *req.UserId
	}
	if req.Uid != nil {
		updates["uid"] = *req.Uid
	}
	if req.OrderUsdAmount != nil {
		updates["order_usd_amount"] = *req.OrderUsdAmount
	}
	if req.PaySymbol != nil {
		updates["pay_symbol"] = *req.PaySymbol
	}
	if req.PaySymbolUsdPrice != nil {
		updates["pay_symbol_usd_price"] = *req.PaySymbolUsdPrice
	}
	if req.PayQuantity != nil {
		updates["pay_quantity"] = *req.PayQuantity
	}
	if req.PayUsdAmount != nil {
		updates["pay_usd_amount"] = *req.PayUsdAmount
	}

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

	c.Resp(payment)
}

// DeleteNodeOrderPayments 删除订单支付信息
func (s *Server) DeleteNodeOrderPayments(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.NodeOrderPayments{}, req.Id).Error; err != nil {
		c.Fail(err.Error())
		return
	}

	c.Resp(nil)
}

// GetNodeOrderPayments 获取订单支付详情
func (s *Server) GetNodeOrderPayments(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
	}

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

	c.Resp(payment)
}

// FindNodeOrderPayments 分页查询订单支付信息
func (s *Server) FindNodeOrderPayments(ctx *gin.Context) {
	c := s.FromContext(ctx)
	type Request struct {
		services.Pagination
		NodeOrderRecordId string `json:"nodeOrderRecordId" form:"nodeOrderRecordId"`
		UserId            int64  `json:"userId" form:"userId"`
		Uid               string `json:"uid" form:"uid"`
		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.NodeOrderPayments{})

	// 条件查询
	if req.NodeOrderRecordId != "" {
		db = db.Where("node_order_record_id = ?", req.NodeOrderRecordId)
	}
	if req.UserId > 0 {
		db = db.Where("user_id = ?", req.UserId)
	}
	if req.Uid != "" {
		db = db.Where("uid = ?", req.Uid)
	}
	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.PageNodeOrderPayments(db, &req.Pagination)
	if err != nil {
		c.Fail(err.Error())
		return
	}

	// 可导出字段列表
	cols := []map[string]string{
		{"field": "id", "label": "ID"},
		{"field": "paymentRecordId", "label": "支付订单ID"},
		{"field": "nodeOrderRecordId", "label": "节点购买记录ID"},
		{"field": "userId", "label": "用户ID"},
		{"field": "uid", "label": "用户UID"},
		{"field": "orderUsdAmount", "label": "订单总价值(USD)"},
		{"field": "paySymbol", "label": "支付币种"},
		{"field": "paySymbolUsdPrice", "label": "支付币种单价"},
		{"field": "payQuantity", "label": "支付数量"},
		{"field": "payUsdAmount", "label": "支付总价值(USD)"},
		{"field": "createdAt", "label": "创建时间"},
	}

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