红包部分接口

models/coin_red_packet.go

+package models
+
+import (
+	"bwallet/pkg/setting"
+	"github.com/jinzhu/gorm"
+	"time"
+)
+
+const (
+	DRAW_NO  = 1
+	DRAW_YES = 2
+)
+
+type CoinRedPacket struct {
+	Model
+
+	PacketId string `json:"packet_id"`
+	LiveId   int32  `json:"live_id"`
+	UserId   int32  `json:"user_id"`
+	Avatar   string `json:"avatar"`
+	Status   uint8  `json:"status"`
+	CreateAt int64  `json:"create_at"`
+	UpdateAt int64  `json:"update_at"`
+
+	RedPacketInfo *CoinRedPacketInfo `gorm:"foreignkey:red_packet_id" json:"red_packet_info"`
+}
+
+func (c CoinRedPacket) TableName() string {
+	return setting.DatabaseSetting.Name_Sources + ".wallet_red_packet"
+}
+
+func ExistCoinByPacketId(packet_id string) (bool, error) {
+	var red_packet CoinRedPacket
+	err := db.Select("id").Where("packet_id = ?", packet_id).First(&red_packet).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return false, err
+	}
+
+	if red_packet.ID > 0 {
+		return true, nil
+	}
+
+	return false, nil
+}
+
+func GetRedPacketsTotal(maps interface{}) (int, error) {
+	var count int
+	if err := db.Model(&CoinRedPacket{}).Where(maps).Count(&count).Error; err != nil {
+		return 0, err
+	}
+
+	return count, nil
+}
+
+func GetRedPackets(pageNum, pageSize int, maps interface{}) ([]*CoinRedPacket, error) {
+	var red_packets []*CoinRedPacket
+	err := db.Preload("RedPacketInfo").Where(maps).Order("create_at desc").Offset(pageNum).Limit(pageSize).Find(&red_packets).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return red_packets, nil
+}
+
+func AddCoinRedPacket(data map[string]interface{}) (error) {
+	coinRedPacketInfo := CoinRedPacket{
+		PacketId: data["packet_id"].(string),
+		LiveId:   data["live_id"].(int32),
+		UserId:   data["user_id"].(int32),
+		Avatar:   data["avatar"].(string),
+		Status:   DRAW_NO,
+		CreateAt: time.Now().UTC().Unix(),
+		UpdateAt: time.Now().UTC().Unix(),
+	}
+	if err := db.Create(&coinRedPacketInfo).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func EditCoinRedPacket(maps interface{}, data interface{}) error {
+	if err := db.Model(&CoinRedPacket{}).Where(maps).Updates(data).Error; err != nil {
+		return err
+	}
+
+	return nil
+}

models/coin_red_packet_info.go

+package models
+
+import (
+	"bwallet/pkg/setting"
+	"github.com/jinzhu/gorm"
+)
+
+type CoinRedPacketInfo struct {
+	Model
+
+	RedPacketId int32   `json:"red_packet_id"`
+	UserId      int32   `json:"user_id"`
+	UserName    string  `json:"user_name"`
+	UserMobile  string  `json:"user_mobile"`
+	PlatformId  int32   `json:"platform_id"`
+	Type        uint8   `json:"type"`
+	CoinId      int32   `json:"coin_id"`
+	CoinName    string  `json:"coin_name"`
+	Amount      float32 `json:"amount"`
+	Size        uint8   `json:"size"`
+	To          string  `json:"to"`
+	Remain      uint8   `json:"remain"`
+	Status      uint8   `json:"status"`
+	Remark      string  `json:"remark"`
+	CreateAt    int32   `json:"create_at"`
+	UpdateAt    int32   `json:"update_at"`
+	ExpiresAt   int32   `json:"expires_at"`
+
+	RedPacket *CoinRedPacket `gorm:"foreignkey:red_packet_id" json:"red_packet"`
+}
+
+func (c CoinRedPacketInfo) TableName() string {
+	return setting.DatabaseSetting.Name_Sources + ".wallet_red_packet_info"
+}
+
+func GetRedPacketsInfo(maps interface{}) ([]*CoinRedPacketInfo, error) {
+	var redPacketsInfo []*CoinRedPacketInfo
+	err := db.Debug().Preload("RedPacket").Where(maps).Find(&redPacketsInfo).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return redPacketsInfo, nil
+}
+
+func AddCoinRedPacketInfo(data map[string]interface{}) (error) {
+	coinRedPacketInfo := CoinRedPacketInfo{
+		RedPacketId: data["red_packet_id"].(int32),
+		UserId:      data["user_id"].(int32),
+		UserName:    data["user_name"].(string),
+		UserMobile:  data["user_mobile"].(string),
+		PlatformId:  data["platform_id"].(int32),
+		Type:        data["type"].(uint8),
+		CoinId:      data["coin_id"].(int32),
+		CoinName:    data["coin_name"].(string),
+		Amount:      data["amount"].(float32),
+		Size:        data["size"].(uint8),
+		To:          data["to"].(string),
+		Remain:      data["remain"].(uint8),
+		Status:      data["status"].(uint8),
+		Remark:      data["remark"].(string),
+		CreateAt:    data["create_at"].(int32),
+		UpdateAt:    data["update_at"].(int32),
+		ExpiresAt:   data["expires_at"].(int32),
+	}
+	if err := db.Create(&coinRedPacketInfo).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func EditCoinRedPacketInfo(maps interface{}, data interface{}) error {
+	if err := db.Model(&CoinRedPacketInfo{}).Where(maps).Updates(data).Error; err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/errno/errno.go

@@ -69,7 +69,7 @@ var (
 	ErrSn         = &Errno{Code: 20004, Message: "Sn error."}
 	ErrAk         = &Errno{Code: 20005, Message: "Ak error."}
 
-	PermissionDenied = &Errno{Code:403, Message:"Permission Denied"}
+	PermissionDenied = &Errno{Code: 403, Message: "Permission Denied"}
 
 	// coin errors
 	ErrCoinNotFound = &Errno{Code: 20101, Message: "The coin was not found."}
@@ -213,4 +213,10 @@ var (
 	ErrUpdateCoinTicker   = &Errno{Code: 20103, Message: "The coin ticker update error."}
 	ErrDeleteCoinTicker   = &Errno{Code: 20104, Message: "The coin ticker delete error."}
 	ErrExistCoinTicker    = &Errno{Code: 20105, Message: "The coin ticker already exists."}
+
+	// red packet errors
+	ErrRedPacketNotFound = &Errno{Code: 20101, Message: "The red packet was not found."}
+	ErrCountRedPacket    = &Errno{Code: 20102, Message: "The red packet statistic error."}
+	ErrAddRedPacket      = &Errno{Code: 20103, Message: "The red packet add error."}
+	ErrExistRedPacket    = &Errno{Code: 20104, Message: "The red packet already exists."}
 )

routers/api/app/red_packet.go

+package app
+
+import (
+	"bwallet/models"
+	"bwallet/pkg/errno"
+	"bwallet/pkg/handler"
+	"bwallet/pkg/util"
+	"bwallet/service/red_packet_info_service"
+	"bwallet/service/red_packet_service"
+	"bwallet/validate_service"
+	"github.com/Unknwon/com"
+	"github.com/astaxie/beego/validation"
+	"github.com/gin-gonic/gin"
+	"strings"
+)
+
+func AddRedPacket(c *gin.Context) {
+	red_packet := validate_service.RedPacket{}
+	c.ShouldBindJSON(&red_packet)
+
+	if ok, errors := validate_service.ValidateInputs(red_packet); !ok {
+		for _, err := range errors {
+			handler.SendResponse(c, errno.ErrBind, strings.Join(err, " "))
+			return
+		}
+	}
+
+	RedPacketService := red_packet_service.CoinRedPacket{
+		PacketId: red_packet.PacketId,
+		LiveId:   red_packet.LiveId,
+		UserId:   red_packet.UserId,
+		Avatar:   red_packet.Avatar,
+	}
+	exist, err := RedPacketService.ExistCoinByPacketId()
+	if err != nil {
+		handler.SendResponse(c, errno.ErrAddRedPacket, nil)
+		return
+	}
+	if exist {
+		handler.SendResponse(c, errno.ErrExistRedPacket, nil)
+		return
+	}
+	if err := RedPacketService.Add(); err != nil {
+		handler.SendResponse(c, errno.ErrAddRedPacket, nil)
+		return
+	}
+
+	handler.SendResponse(c, nil, nil)
+}
+
+func GetRedPackets(c *gin.Context) {
+	valid := validation.Validation{}
+
+	live_id := com.StrTo(c.DefaultQuery("live_id", "0")).MustInt()
+	valid.Required(live_id, "live_id").Message("直播间参数不能为空")
+
+	if valid.HasErrors() {
+		handler.SendResponse(c, valid.Errors[0], nil)
+		return
+	}
+
+	RedPacketService := red_packet_service.CoinRedPacket{
+		LiveId:   int32(live_id),
+		Status:   models.DRAW_NO,
+		PageNum:  util.GetPage(c),
+		PageSize: util.GetLimit(c),
+	}
+
+	info, err := RedPacketService.GetRedPackets()
+	if err != nil {
+		handler.SendResponse(c, errno.InternalServerError, nil)
+		return
+	}
+
+	data := make(map[string]interface{})
+	data["items"] = info
+	data["total"] = len(info)
+
+	handler.SendResponse(c, nil, data)
+}
+
+func GetRedPacketsInfo(c *gin.Context) {
+	RedPacketInfoService := red_packet_info_service.CoinRedPacketInfo{
+		Status: 1,
+	}
+
+	info, err := RedPacketInfoService.GetRedPacketsInfo()
+	if err != nil {
+		handler.SendResponse(c, errno.InternalServerError, nil)
+		return
+	}
+
+	handler.SendResponse(c, nil, info)
+}

routers/router.go

@@ -51,6 +51,10 @@ func InitRouter() *gin.Engine {
 	client.GET("/fees/recommended", app.GetTransactionGas)
 	client.GET("/tokenview/explore", app.Explore)
 
+	client.GET("/red-packets", app.GetRedPackets)
+	client.POST("/red-packet", app.AddRedPacket)
+	client.GET("/red-packets-info", app.GetRedPacketsInfo)
+
 	api := r.Group("/api")
 
 	api.Use(jwt.JWT()).Use(auth.AUTH())

service/red_packet_info_service/red_packet_info.go

+package red_packet_info_service
+
+import (
+	"bwallet/models"
+)
+
+type CoinRedPacketInfo struct {
+	RedPacketId int32
+	UserId      int32
+	UserName    string
+	UserMobile  string
+	PlatformId  int32
+	Type        uint8
+	CoinId      int32
+	CoinName    string
+	Amount      float32
+	Size        uint8
+	To          string
+	Remain      uint8
+	Status      uint8
+	Remark      string
+	CreateAt    int32
+	UpdateAt    int32
+	ExpiresAt   int32
+}
+
+func (r *CoinRedPacketInfo) GetRedPacketsInfo() ([]*models.CoinRedPacketInfo, error) {
+	redPacketsInfo, err := models.GetRedPacketsInfo(r.getMaps())
+	if err != nil {
+		return nil, err
+	}
+
+	return redPacketsInfo, nil
+}
+
+func (r *CoinRedPacketInfo) Add() error {
+	redPacket := map[string]interface{}{
+		"red_packet_id": r.RedPacketId,
+		"user_id":       r.UserId,
+		"user_name":     r.UserName,
+		"user_mobile":   r.UserMobile,
+		"platform_id":   r.PlatformId,
+		"type":          r.Type,
+		"coin_id":       r.CoinId,
+		"coin_name":     r.CoinName,
+		"amount":        r.Amount,
+		"size":          r.Size,
+		"to":            r.To,
+		"remain":        r.Remain,
+		"status":        r.Status,
+		"remark":        r.Remark,
+		"create_at":     r.CreateAt,
+		"update_at":     r.UpdateAt,
+		"expires_at":    r.ExpiresAt,
+	}
+
+	if err := models.AddCoinRedPacketInfo(redPacket); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (r *CoinRedPacketInfo) Edit() error {
+	return models.EditCoinRedPacketInfo(r.getMaps(), map[string]interface{}{
+		"user_id":     r.UserId,
+		"user_name":   r.UserName,
+		"user_mobile": r.UserMobile,
+		"platform_id": r.PlatformId,
+		"type":        r.Type,
+		"coin_id":     r.CoinId,
+		"coin_name":   r.CoinName,
+		"amount":      r.Amount,
+		"size":        r.Size,
+		"to":          r.To,
+		"remain":      r.Remain,
+		"status":      r.Status,
+		"remark":      r.Remark,
+		"create_at":   r.CreateAt,
+		"update_at":   r.UpdateAt,
+		"expires_at":  r.ExpiresAt,
+	})
+}
+
+func (r *CoinRedPacketInfo) getMaps() (map[string]interface{}) {
+	maps := make(map[string]interface{})
+
+	if r.UserId != 0 {
+		maps["user_id"] = r.UserId
+	}
+
+	if r.Status != 0 {
+		maps["status"] = r.Status
+	}
+	return maps
+}

service/red_packet_service/red_packet.go

+package red_packet_service
+
+import (
+	"bwallet/models"
+	"time"
+)
+
+type CoinRedPacket struct {
+	PacketId string
+	LiveId   int32
+	UserId   int32
+	Avatar   string
+	Status   uint8
+
+	PageNum  int
+	PageSize int
+}
+
+type CoinRedPacketResp struct {
+	Status     uint8   `json:"status"`
+	CoinName   string  `json:"coin_name"`
+	Amount     float32 `json:"amount"`
+	Size       uint8   `json:"size"`
+	Remain     uint8   `json:"remain"`
+	Avatar     string  `json:"avatar"`
+	UserName   string  `json:"user_name"`
+	UserMobile string  `json:"user_mobile"`
+}
+
+func (r *CoinRedPacket) ExistCoinByPacketId() (bool, error) {
+	return models.ExistCoinByPacketId(r.PacketId)
+}
+
+func (r *CoinRedPacket) Count() (int, error) {
+	return models.GetRedPacketsTotal(r.getMaps())
+}
+
+func (r *CoinRedPacket) GetRedPackets() ([]*CoinRedPacketResp, error) {
+	redPackets, err := models.GetRedPackets(r.PageNum, r.PageSize, r.getMaps())
+	if err != nil {
+		return nil, err
+	}
+
+	var redPacketsResp = []*CoinRedPacketResp{}
+	for _, val := range redPackets {
+		if val.RedPacketInfo != nil && val.RedPacketInfo.Status == 1 {
+			tmp := &CoinRedPacketResp{}
+			tmp.Status = val.Status
+			tmp.Avatar = val.Avatar
+			tmp.Size = val.RedPacketInfo.Size
+			tmp.Remain = val.RedPacketInfo.Remain
+			tmp.Amount = val.RedPacketInfo.Amount
+			tmp.CoinName = val.RedPacketInfo.CoinName
+			tmp.UserName = val.RedPacketInfo.UserName
+			tmp.UserMobile = val.RedPacketInfo.UserMobile
+
+			redPacketsResp = append(redPacketsResp, tmp)
+		}
+	}
+
+	return redPacketsResp, nil
+}
+
+func (r *CoinRedPacket) Add() error {
+	redPacket := map[string]interface{}{
+		"packet_id": r.PacketId,
+		"live_id":   r.LiveId,
+		"user_id":   r.UserId,
+		"avatar":    r.Avatar,
+	}
+	if err := models.AddCoinRedPacket(redPacket); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (r *CoinRedPacket) Edit() error {
+	return models.EditCoinRedPacket(r.getMaps(), map[string]interface{}{
+		"status":    models.DRAW_YES,
+		"update_at": time.Now().UTC().Unix(),
+	})
+}
+
+func (r *CoinRedPacket) getMaps() (map[string]interface{}) {
+	maps := make(map[string]interface{})
+
+	if r.PacketId != "" {
+		maps["packet_id"] = r.PacketId
+	}
+
+	if r.LiveId != 0 {
+		maps["live_id"] = r.LiveId
+	}
+
+	if r.UserId != 0 {
+		maps["user_id"] = r.UserId
+	}
+
+	if r.Status != 0 {
+		maps["status"] = r.Status
+	}
+
+	return maps
+}

validate_service/red_packet.go

+package validate_service
+
+type RedPacket struct {
+	PacketId string `json:"packet_id" validate:"required"`
+	LiveId   int32  `json:"live_id" validate:"required"`
+	UserId   int32  `json:"user_id" validate:"required"`
+	Avatar   string `json:"avatar"  validate:"omitempty"`
+}