Merge branch 'feature/redpacket' into 'master'

models/chain.go

@@ -2,7 +2,6 @@ package models
 
 import (
 	"bwallet/pkg/setting"
-	"fmt"
 	"github.com/jinzhu/gorm"
 )
 
@@ -140,7 +139,6 @@ func GetChain(id int) (*Chain, error) {
  * @return
  */
 func AddChain(data map[string]interface{}) (error) {
-	fmt.Println(data)
 	chain := Chain{
 		Platform:   data["platform"].(string),
 		Address:    data["address"].(string),

models/manager.go

@@ -2,7 +2,6 @@ package models
 
 import (
 	"bwallet/pkg/setting"
-	"fmt"
 	"github.com/jinzhu/gorm"
 	"time"
 )
@@ -85,7 +84,6 @@ func GetManagers(pageNum, pageSize int, maps interface{}) ([]*Manager, error) {
 			delete(maps.(map[string]interface{}),"uid")
 		}
 	}
-	fmt.Println(maps)
 	err := db.Where(maps).Where("uid <> ?", uid).Order("uid desc").Offset(pageNum).Limit(pageSize).Find(&manager).Error
 	if err != nil && err != gorm.ErrRecordNotFound {
 		return nil, err

models/red_packet.go

+package models
+
+import (
+	"bwallet/pkg/setting"
+	"github.com/jinzhu/gorm"
+	"time"
+)
+
+type RedPacket struct {
+	Model
+
+	PacketId   string  `json:"packet_id"`
+	LiveId     int32   `json:"live_id"`
+	Avatar     string  `json:"avatar"`
+	Receive    string  `json:"receive"`
+	UserId     string  `json:"user_id"`
+	UserName   string  `json:"user_name"`
+	UserMobile string  `json:"user_mobile"`
+	PlatformId string  `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"`
+	ExpireAt   int32   `json:"expire_at"`
+}
+
+func (c RedPacket) TableName() string {
+	return setting.DatabaseSetting.Name_Sources + ".wallet_red_packet"
+}
+
+func ExistByPacketInfoId(packet_id string) (bool, error) {
+	var red_packet_info RedPacket
+	err := db.Select("id").Where("packet_id = ?", packet_id).First(&red_packet_info).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return false, err
+	}
+
+	if red_packet_info.ID > 0 {
+		return true, nil
+	}
+
+	return false, nil
+}
+
+func GetRedPackets(maps interface{}) ([]*RedPacket, error) {
+	var redPackets []*RedPacket
+	err := db.Where(maps).Find(&redPackets).Error
+	if err != nil && err != gorm.ErrRecordNotFound {
+		return nil, err
+	}
+
+	return redPackets, nil
+}
+
+func GetRedPacketsForReceive() ([]*RedPacket, error) {
+	var redPackets []*RedPacket
+	status_map := [] int{1, 2, 4}
+	if err := db.Where("status in (?)", status_map).Where("expire_at > (?)", time.Now().UTC().Unix()).Find(&redPackets).Error; err != nil {
+		return nil, err
+	}
+
+	return redPackets, nil
+}
+
+func AddRedPacket(data map[string]interface{}) (error) {
+	redPacket := RedPacket{
+		PacketId:   data["packet_id"].(string),
+		LiveId:     data["live_id"].(int32),
+		Avatar:     data["avatar"].(string),
+		Receive:    data["receive"].(string),
+		UserId:     data["user_id"].(string),
+		UserName:   data["user_name"].(string),
+		UserMobile: data["user_mobile"].(string),
+		PlatformId: data["platform_id"].(string),
+		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),
+		ExpireAt:   data["expire_at"].(int32),
+	}
+
+	if err := db.Create(&redPacket).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func EditRedPacket(maps interface{}, data interface{}) error {
+	if err := db.Model(&RedPacket{}).Where(maps).Updates(data).Error; err != nil {
+		return err
+	}
+
+	return nil
+}

pkg/cron/cron.go

@@ -2,17 +2,26 @@ package cron
 
 import (
 	"bwallet/service/coin_gas_service"
+	"bwallet/service/red_packet_service"
 	"github.com/robfig/cron"
 )
 
 var c *cron.Cron
 
-func Setup(){
+func Setup() {
 	c = cron.New()
 
 	c.AddFunc("* * * * * *", func() {
 		coin_gas_service.TokenView()
 	})
 
+	c.AddFunc("* * * * * *", func() {
+		red_packet_service.UpdateReceive()
+	})
+
+	c.AddFunc("* * * * * *", func() {
+		red_packet_service.UpdateInfo()
+	})
+
 	c.Start()
 }

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/pkg/errno"
+	"bwallet/pkg/handler"
+	"bwallet/service/red_packet_service"
+	"bwallet/validate_service"
+	"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.RedPacket{
+		PacketId: red_packet.PacketId,
+		LiveId:   red_packet.LiveId,
+		Avatar:   red_packet.Avatar,
+	}
+	exist, err := RedPacketService.ExistByPacketInfoId()
+	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) {
+	red_packet := validate_service.RedPacketReq{}
+	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.RedPacket{
+		LiveId: int32(red_packet.LiveId),
+		UserId: red_packet.UserId,
+		Status: 1,
+	}
+
+	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)
+}

routers/router.go

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

service/red_packet_service/red_packet.go

+package red_packet_service
+
+import (
+	"bwallet/models"
+	"bwallet/pkg/util"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"strings"
+)
+
+type RedPacketInfoResult struct {
+	UserId     string  `json:"user_id"`
+	UserName   string  `json:"user_name"`
+	UserMobile string  `json:"user_mobile"`
+	PlatformId string  `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"`
+	ExpireAt   int32   `json:"expire_at"`
+}
+
+type RedPacketInfoError struct {
+	Code    int32  `json:"code"`
+	Message string `json:"message"`
+}
+
+type RedPacketInfoResp struct {
+	Id     int32
+	Result RedPacketInfoResult
+	Error  RedPacketInfoError
+}
+
+type RedPacketReceiveDetailResp struct {
+	Id     int32
+	Result RedPacketReceiveDetailResult
+	Error  RedPacketInfoError
+}
+
+type RedPacketReceiveDetailResult struct {
+	Rows []RedPacketReceiveDetailRowResult `json:"rows"`
+}
+
+type RedPacketReceiveDetailRowResult struct {
+	Id         int32   `json:"id"`
+	UserId     string  `json:"user_id"`
+	UserName   string  `json:"user_name"`
+	UserMobile string  `json:"user_mobile"`
+	PlatformId string  `json:"platform_id"`
+	CoinId     int32   `json:"coin_id"`
+	CoinName   string  `json:"coin_name"`
+	Amount     float32 `json:"amount"`
+	Status     uint8   `json:"status"`
+	CreateAt   int32   `json:"create_at"`
+}
+
+type Params struct {
+	PacketId string `json:"packet_id"`
+}
+
+type RedPacketInfoReq struct {
+	Method string `json:"method"`
+	Params Params `json:"params"`
+}
+
+type RedPacket struct {
+	PacketId      string `json:"packet_id"`
+	LiveId        int32  `json:"live_id"`
+	Avatar        string `json:"avatar"`
+	Receive       string `json:"receive"`
+	UserId        int32  `json:"user_id"`
+	Status        uint8  `json:"status"`
+	RedPacketInfo RedPacketInfoResp
+}
+
+type RedPacketResp struct {
+	PacketId      string  `json:"packet_id"`
+	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"`
+	ReceiveStatus uint8   `json:"receive_status"`
+}
+
+func (r *RedPacket) ExistByPacketInfoId() (bool, error) {
+	return models.ExistByPacketInfoId(r.PacketId)
+}
+
+func (r *RedPacket) GetRedPackets() ([]*RedPacketResp, error) {
+	redPacketsInfo, err := models.GetRedPackets(r.getMaps())
+	if err != nil {
+		return nil, err
+	}
+
+	var redPacketResp = []*RedPacketResp{}
+	for _, val := range redPacketsInfo {
+		if strings.Contains(util.ToString(val.Receive), util.ToString(r.UserId)) {
+			continue
+		}
+		tmp := &RedPacketResp{}
+		tmp.PacketId = val.PacketId
+		tmp.CoinName = val.CoinName
+		tmp.Amount = val.Amount
+		tmp.Size = val.Size
+		tmp.Remain = val.Remain
+		tmp.Avatar = val.Avatar
+		tmp.UserName = val.UserName
+		tmp.UserMobile = val.UserMobile
+		redPacketResp = append(redPacketResp, tmp)
+	}
+
+	return redPacketResp, nil
+}
+
+func (r *RedPacket) Add() error {
+	url := "https://redback.biqianbao.net/red-packet"
+
+	var params RedPacketInfoReq
+	params.Method = "Info"
+	params.Params.PacketId = r.PacketId
+	jsonStr, err := json.Marshal(params)
+	if err != nil {
+		return err
+	}
+
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonStr))
+	req.Header.Set("Content-Type", "application/json")
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	body, _ := ioutil.ReadAll(resp.Body)
+
+	var redPacketResp RedPacketInfoResp
+	err = json.Unmarshal(body, &redPacketResp)
+	if err != nil {
+		return err
+	}
+	if redPacketResp.Error.Code != 0 {
+		fmt.Println(redPacketResp.Error.Message)
+	}
+
+	redPacket := map[string]interface{}{
+		"packet_id":   r.PacketId,
+		"live_id":     r.LiveId,
+		"avatar":      r.Avatar,
+		"receive":     "[]",
+		"user_id":     redPacketResp.Result.UserId,
+		"user_name":   redPacketResp.Result.UserName,
+		"user_mobile": redPacketResp.Result.UserMobile,
+		"platform_id": redPacketResp.Result.PlatformId,
+		"type":        redPacketResp.Result.Type,
+		"coin_id":     redPacketResp.Result.CoinId,
+		"coin_name":   redPacketResp.Result.CoinName,
+		"amount":      redPacketResp.Result.Amount,
+		"size":        redPacketResp.Result.Size,
+		"to":          redPacketResp.Result.To,
+		"remain":      redPacketResp.Result.Remain,
+		"status":      redPacketResp.Result.Status,
+		"remark":      redPacketResp.Result.Remark,
+		"create_at":   redPacketResp.Result.CreateAt,
+		"update_at":   redPacketResp.Result.UpdateAt,
+		"expire_at":   redPacketResp.Result.ExpireAt,
+	}
+
+	if err := models.AddRedPacket(redPacket); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (r *RedPacket) Edit() error {
+	return models.EditRedPacket(r.getMaps(), map[string]interface{}{
+		"remain":    r.RedPacketInfo.Result.Remain,
+		"status":    r.RedPacketInfo.Result.Status,
+		"update_at": r.RedPacketInfo.Result.UpdateAt,
+	})
+}
+
+func UpdateReceive() error {
+	redPacketsInfo, err := models.GetRedPacketsForReceive()
+	if err != nil {
+		return err
+	}
+	url := "https://redback.biqianbao.net/red-packet"
+	for _, val := range redPacketsInfo {
+		var params RedPacketInfoReq
+		params.Method = "ReceiveDetail"
+		params.Params.PacketId = val.PacketId
+		jsonStr, _ := json.Marshal(params)
+		if err != nil {
+			continue
+		}
+
+		req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonStr))
+		req.Header.Set("Content-Type", "application/json")
+
+		client := &http.Client{}
+		resp, err := client.Do(req)
+		if err != nil {
+			continue
+		}
+		defer resp.Body.Close()
+
+		body, _ := ioutil.ReadAll(resp.Body)
+
+		var redPacketReceiveDetailResp RedPacketReceiveDetailResp
+		err = json.Unmarshal(body, &redPacketReceiveDetailResp)
+		if err != nil {
+			continue
+		}
+		if redPacketReceiveDetailResp.Error.Code != 0 {
+			continue
+		}
+		var receive = []int{20063}
+		for _, item := range redPacketReceiveDetailResp.Result.Rows {
+			receive = append(receive, util.ToInt(item.UserId))
+		}
+
+		jsonString, err := json.Marshal(receive)
+		if err != nil {
+			continue
+		}
+
+		maps := make(map[string]interface{})
+		maps["packet_id"] = val.PacketId
+		models.EditRedPacket(maps, map[string]interface{}{
+			"receive": string(jsonString),
+		})
+	}
+
+	return nil
+}
+
+func UpdateInfo() error {
+	maps := make(map[string]interface{})
+	maps["status"] = 1
+	redPacketsInfo, err := models.GetRedPackets(maps)
+	if err != nil {
+		return err
+	}
+	url := "https://redback.biqianbao.net/red-packet"
+	for _, val := range redPacketsInfo {
+		var params RedPacketInfoReq
+		params.Method = "Info"
+		params.Params.PacketId = val.PacketId
+		jsonStr, _ := json.Marshal(params)
+		if err != nil {
+			continue
+		}
+
+		req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonStr))
+		req.Header.Set("Content-Type", "application/json")
+
+		client := &http.Client{}
+		resp, err := client.Do(req)
+		if err != nil {
+			continue
+		}
+		defer resp.Body.Close()
+
+		body, _ := ioutil.ReadAll(resp.Body)
+
+		var redPacketInfoResp RedPacketInfoResp
+		err = json.Unmarshal(body, &redPacketInfoResp)
+		if err != nil {
+			continue
+		}
+		var redPacketResp RedPacketInfoResp
+		err = json.Unmarshal(body, &redPacketResp)
+		if err != nil {
+			return err
+		}
+		if redPacketResp.Error.Code != 0 {
+			fmt.Println(redPacketResp.Error.Message)
+		}
+		if val.UpdateAt != redPacketResp.Result.UpdateAt {
+			redPacket := map[string]interface{}{
+				"remain":    redPacketResp.Result.Remain,
+				"status":    redPacketResp.Result.Status,
+				"update_at": redPacketResp.Result.UpdateAt,
+			}
+			condition := make(map[string]interface{})
+			condition["id"] = val.ID
+			models.EditRedPacket(condition, redPacket)
+		}
+	}
+
+	return nil
+}
+
+func (r *RedPacket) getMaps() (map[string]interface{}) {
+	maps := make(map[string]interface{})
+
+	if r.LiveId != 0 {
+		maps["live_id"] = r.LiveId
+	}
+
+	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"`
+	Avatar   string `json:"avatar"  validate:"omitempty"`
+}
+
+type RedPacketReq struct {
+	LiveId int32 `json:"live_id" validate:"required"`
+	UserId int32 `json:"user_id" validate:"required"`
+}