322 lines
10 KiB
Go
322 lines
10 KiB
Go
package v1
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"strconv"
|
|
"time"
|
|
|
|
"google.golang.org/grpc/status"
|
|
|
|
"go-common/library/log"
|
|
|
|
"github.com/pkg/errors"
|
|
|
|
v1pb "go-common/app/interface/live/web-ucenter/api/http/v1"
|
|
"go-common/app/interface/live/web-ucenter/conf"
|
|
capsuledao "go-common/app/interface/live/web-ucenter/dao/capsule"
|
|
"go-common/library/log/infoc"
|
|
bm "go-common/library/net/http/blademaster"
|
|
"go-common/library/net/metadata"
|
|
)
|
|
|
|
// CapsuleService struct
|
|
type CapsuleService struct {
|
|
conf *conf.Config
|
|
// optionally add other properties here, such as dao
|
|
dao *capsuledao.Dao
|
|
infoc *infoc.Infoc
|
|
}
|
|
|
|
//NewCapsuleService init
|
|
func NewCapsuleService(c *conf.Config) (s *CapsuleService) {
|
|
s = &CapsuleService{
|
|
conf: c,
|
|
dao: capsuledao.New(c),
|
|
}
|
|
if c.Infoc != nil && c.Infoc.CapsuleInfoc != nil {
|
|
s.infoc = infoc.New(c.Infoc.CapsuleInfoc)
|
|
}
|
|
return s
|
|
}
|
|
|
|
// GetDetail implementation
|
|
func (s *CapsuleService) GetDetail(ctx context.Context, req *v1pb.CapsuleGetDetailReq) (resp *v1pb.CapsuleGetDetailResp, err error) {
|
|
resp = &v1pb.CapsuleGetDetailResp{}
|
|
uid, ok := metadata.Value(ctx, metadata.Mid).(int64)
|
|
if !ok {
|
|
err = errors.Wrap(err, "未取到uid")
|
|
return
|
|
}
|
|
data, err := s.dao.GetDetail(ctx, uid, req.From)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if data.Normal != nil {
|
|
normal := &v1pb.CapsuleGetDetailResp_CapsuleInfo{}
|
|
normal.Status = data.Normal.Status
|
|
normal.Coin = data.Normal.Coin
|
|
normal.Change = data.Normal.Change
|
|
normal.Rule = data.Normal.Rule
|
|
if data.Normal.Progress != nil {
|
|
normal.Progress = &v1pb.Progress{}
|
|
normal.Progress.Now = data.Normal.Progress.Now
|
|
normal.Progress.Max = data.Normal.Progress.Max
|
|
}
|
|
glen := len(data.Normal.Gift)
|
|
normal.Gift = make([]*v1pb.CapsuleGetDetailResp_Gift, glen)
|
|
for i := 0; i < glen; i++ {
|
|
gift := &v1pb.CapsuleGetDetailResp_Gift{}
|
|
gift.Name = data.Normal.Gift[i].Name
|
|
gift.WebImage = data.Normal.Gift[i].WebImage
|
|
gift.MobileImage = data.Normal.Gift[i].MobileImage
|
|
gift.Image = data.Normal.Gift[i].Image
|
|
if data.Normal.Gift[i].Usage != nil {
|
|
gift.Usage = &v1pb.Usage{}
|
|
gift.Usage.Text = data.Normal.Gift[i].Usage.Text
|
|
gift.Usage.Url = data.Normal.Gift[i].Usage.Url
|
|
}
|
|
normal.Gift[i] = gift
|
|
}
|
|
glen = len(data.Normal.List)
|
|
normal.List = make([]*v1pb.CapsuleGetDetailResp_List, glen)
|
|
for i := 0; i < glen; i++ {
|
|
info := &v1pb.CapsuleGetDetailResp_List{}
|
|
info.Name = data.Normal.List[i].Name
|
|
info.Num = data.Normal.List[i].Num
|
|
info.Date = data.Normal.List[i].Date
|
|
info.Gift = data.Normal.List[i].Gift
|
|
normal.List[i] = info
|
|
}
|
|
resp.Normal = normal
|
|
}
|
|
if data.Colorful != nil {
|
|
colorful := &v1pb.CapsuleGetDetailResp_CapsuleInfo{}
|
|
colorful.Status = data.Colorful.Status
|
|
colorful.Coin = data.Colorful.Coin
|
|
colorful.Change = data.Colorful.Change
|
|
colorful.Rule = data.Colorful.Rule
|
|
if data.Colorful.Progress != nil {
|
|
colorful.Progress = &v1pb.Progress{}
|
|
colorful.Progress.Now = data.Colorful.Progress.Now
|
|
colorful.Progress.Max = data.Colorful.Progress.Max
|
|
}
|
|
glen := len(data.Colorful.Gift)
|
|
colorful.Gift = make([]*v1pb.CapsuleGetDetailResp_Gift, glen)
|
|
for i := 0; i < glen; i++ {
|
|
gift := &v1pb.CapsuleGetDetailResp_Gift{}
|
|
gift.Name = data.Colorful.Gift[i].Name
|
|
gift.WebImage = data.Colorful.Gift[i].WebImage
|
|
gift.MobileImage = data.Colorful.Gift[i].MobileImage
|
|
gift.Image = data.Colorful.Gift[i].Image
|
|
if data.Colorful.Gift[i].Usage != nil {
|
|
gift.Usage = &v1pb.Usage{}
|
|
gift.Usage.Text = data.Colorful.Gift[i].Usage.Text
|
|
gift.Usage.Url = data.Colorful.Gift[i].Usage.Url
|
|
}
|
|
colorful.Gift[i] = gift
|
|
}
|
|
glen = len(data.Colorful.List)
|
|
colorful.List = make([]*v1pb.CapsuleGetDetailResp_List, glen)
|
|
for i := 0; i < glen; i++ {
|
|
info := &v1pb.CapsuleGetDetailResp_List{}
|
|
info.Name = data.Colorful.List[i].Name
|
|
info.Num = data.Colorful.List[i].Num
|
|
info.Date = data.Colorful.List[i].Date
|
|
info.Gift = data.Colorful.List[i].Gift
|
|
colorful.List[i] = info
|
|
}
|
|
resp.Colorful = colorful
|
|
}
|
|
return
|
|
}
|
|
|
|
// OpenCapsule implementation
|
|
func (s *CapsuleService) OpenCapsule(ctx context.Context, req *v1pb.CapsuleOpenCapsuleReq) (resp *v1pb.CapsuleOpenCapsuleResp, err error) {
|
|
resp = &v1pb.CapsuleOpenCapsuleResp{}
|
|
uid, ok := metadata.Value(ctx, metadata.Mid).(int64)
|
|
if !ok {
|
|
err = errors.Wrap(err, "未取到uid")
|
|
return
|
|
}
|
|
data, err := s.dao.OpenCapsule(ctx, uid, req.Type, req.Count, req.Platform)
|
|
if err != nil {
|
|
return
|
|
}
|
|
if data.Info != nil {
|
|
resp.Info = &v1pb.CapsuleOpenCapsuleResp_Info{}
|
|
if data.Info.Colorful != nil {
|
|
resp.Info.Colorful = &v1pb.CapsuleOpenCapsuleResp_CapsuleInfo{}
|
|
resp.Info.Colorful.Change = data.Info.Colorful.Change
|
|
resp.Info.Colorful.Coin = data.Info.Colorful.Coin
|
|
if data.Info.Colorful.Progress != nil {
|
|
resp.Info.Colorful.Progress = &v1pb.Progress{}
|
|
resp.Info.Colorful.Progress.Max = data.Info.Colorful.Progress.Max
|
|
resp.Info.Colorful.Progress.Now = data.Info.Colorful.Progress.Now
|
|
}
|
|
}
|
|
if data.Info.Normal != nil {
|
|
resp.Info.Normal = &v1pb.CapsuleOpenCapsuleResp_CapsuleInfo{}
|
|
resp.Info.Normal.Change = data.Info.Normal.Change
|
|
resp.Info.Normal.Coin = data.Info.Normal.Coin
|
|
if data.Info.Normal.Progress != nil {
|
|
resp.Info.Normal.Progress = &v1pb.Progress{}
|
|
resp.Info.Normal.Progress.Max = data.Info.Normal.Progress.Max
|
|
resp.Info.Normal.Progress.Now = data.Info.Normal.Progress.Now
|
|
}
|
|
}
|
|
}
|
|
resp.Status = data.Status
|
|
resp.IsEntity = data.IsEntity
|
|
resp.ShowTitle = data.ShowTitle
|
|
resp.Text = data.Text
|
|
l := len(data.Awards)
|
|
resp.Awards = make([]*v1pb.CapsuleOpenCapsuleResp_Award, l)
|
|
for i := 0; i < l; i++ {
|
|
resp.Awards[i] = &v1pb.CapsuleOpenCapsuleResp_Award{}
|
|
resp.Awards[i].Num = data.Awards[i].Num
|
|
resp.Awards[i].Name = data.Awards[i].Name
|
|
resp.Awards[i].Text = data.Awards[i].Text
|
|
resp.Awards[i].MobileImage = data.Awards[i].MobileImage
|
|
resp.Awards[i].WebImage = data.Awards[i].WebImage
|
|
resp.Awards[i].Img = data.Awards[i].Img
|
|
if data.Awards[i].Usage != nil {
|
|
resp.Awards[i].Usage = &v1pb.Usage{}
|
|
resp.Awards[i].Usage.Text = data.Awards[i].Usage.Text
|
|
resp.Awards[i].Usage.Url = data.Awards[i].Usage.Url
|
|
}
|
|
}
|
|
if s.infoc != nil {
|
|
awards, err1 := json.Marshal(resp.Awards)
|
|
if err1 != nil {
|
|
log.Error("OpenCapsule OpenCapsule err")
|
|
return
|
|
}
|
|
bmc, ok := ctx.(bm.Context)
|
|
if !ok {
|
|
return
|
|
}
|
|
header := bmc.Request.Header
|
|
userip := header.Get("x-backend-bili-real-ip")
|
|
if userip == "" {
|
|
userip = bmc.Request.RemoteAddr
|
|
}
|
|
s.infoc.Infov(context.Background(), uid, userip, strconv.FormatInt(time.Now().Unix(), 10), awards, header.Get("platform"), header.Get("version"), header.Get("buvid"), bmc.Request.UserAgent(), bmc.Request.Referer())
|
|
}
|
|
return
|
|
}
|
|
|
|
// FormatErr format error msg
|
|
func (s *CapsuleService) FormatErr(statusCode *status.Status) (code int32, msg string) {
|
|
gCode := statusCode.Code()
|
|
fmt.Printf("FormatErr %d %s", gCode, statusCode.Message())
|
|
code = 1
|
|
if gCode == 2 {
|
|
code, _ := strconv.Atoi(statusCode.Message())
|
|
|
|
switch code {
|
|
case -400:
|
|
msg = "参数错误"
|
|
case -401:
|
|
msg = "扭蛋币不足"
|
|
case -500:
|
|
msg = "系统繁忙，请稍后再试"
|
|
case -501:
|
|
msg = "系统繁忙，请稍后再试"
|
|
default:
|
|
msg = "系统繁忙，请稍后再试"
|
|
}
|
|
} else {
|
|
msg = "系统繁忙，请稍后再试"
|
|
}
|
|
return
|
|
}
|
|
|
|
// GetCapsuleInfo implementation
|
|
// `midware:"guest"`
|
|
func (s *CapsuleService) GetCapsuleInfo(ctx context.Context, req *v1pb.CapsuleGetCapsuleInfoReq) (resp *v1pb.CapsuleGetCapsuleInfoResp, err error) {
|
|
resp = &v1pb.CapsuleGetCapsuleInfoResp{}
|
|
uid, _ := metadata.Value(ctx, metadata.Mid).(int64)
|
|
data, err := s.dao.GetCapsuleInfo(ctx, uid, req.Type, req.From)
|
|
if err != nil || data == nil {
|
|
return
|
|
}
|
|
resp.Coin = data.Coin
|
|
resp.Rule = data.Rule
|
|
if len(data.GiftFilter) > 0 {
|
|
resp.GiftFilter = make([]*v1pb.CapsuleGetCapsuleInfoResp_GiftFilter, len(data.GiftFilter))
|
|
for ix, award := range data.GiftFilter {
|
|
resp.GiftFilter[ix] = &v1pb.CapsuleGetCapsuleInfoResp_GiftFilter{}
|
|
resp.GiftFilter[ix].Id = award.Id
|
|
resp.GiftFilter[ix].Name = award.Name
|
|
resp.GiftFilter[ix].WebUrl = award.WebUrl
|
|
resp.GiftFilter[ix].MobileUrl = award.MobileUrl
|
|
if award.Usage != nil {
|
|
resp.GiftFilter[ix].Usage = &v1pb.Usage{}
|
|
resp.GiftFilter[ix].Usage.Text = award.Usage.Text
|
|
resp.GiftFilter[ix].Usage.Url = award.Usage.Url
|
|
}
|
|
}
|
|
}
|
|
if len(data.GiftList) > 0 {
|
|
resp.GiftList = make([]*v1pb.CapsuleGetCapsuleInfoResp_GiftList, len(data.GiftList))
|
|
for ix, award := range data.GiftList {
|
|
resp.GiftList[ix] = &v1pb.CapsuleGetCapsuleInfoResp_GiftList{}
|
|
resp.GiftList[ix].Id = award.Id
|
|
resp.GiftList[ix].Name = award.Name
|
|
resp.GiftList[ix].Num = award.Num
|
|
resp.GiftList[ix].WebUrl = award.WebUrl
|
|
resp.GiftList[ix].MobileUrl = award.MobileUrl
|
|
resp.GiftList[ix].Type = award.Type
|
|
resp.GiftList[ix].Expire = award.Expire
|
|
if award.Usage != nil {
|
|
resp.GiftList[ix].Usage = &v1pb.Usage{}
|
|
resp.GiftList[ix].Usage.Text = award.Usage.Text
|
|
resp.GiftList[ix].Usage.Url = award.Usage.Url
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// OpenCapsuleByType implementation
|
|
// `method:"POST" midware:"auth"`
|
|
func (s *CapsuleService) OpenCapsuleByType(ctx context.Context, req *v1pb.CapsuleOpenCapsuleByTypeReq) (resp *v1pb.CapsuleOpenCapsuleByTypeResp, err error) {
|
|
resp = &v1pb.CapsuleOpenCapsuleByTypeResp{}
|
|
uid, ok := metadata.Value(ctx, metadata.Mid).(int64)
|
|
if !ok {
|
|
err = errors.Wrap(err, "未取到uid")
|
|
return
|
|
}
|
|
data, err := s.dao.OpenCapsuleByType(ctx, uid, req.Type, req.Count, req.Platform)
|
|
if err != nil || data == nil {
|
|
return
|
|
}
|
|
resp.IsEntity = data.IsEntity
|
|
resp.Status = data.Status
|
|
resp.Text = data.Text
|
|
resp.Info = &v1pb.CapsuleOpenCapsuleByTypeResp_CapsuleInfo{Coin: 0}
|
|
if data.Info != nil {
|
|
resp.Info.Coin = data.Info.Coin
|
|
}
|
|
resp.Awards = make([]*v1pb.CapsuleOpenCapsuleByTypeResp_Award, len(data.Awards))
|
|
for ix, award := range data.Awards {
|
|
resp.Awards[ix] = &v1pb.CapsuleOpenCapsuleByTypeResp_Award{}
|
|
resp.Awards[ix].Id = award.Id
|
|
resp.Awards[ix].Name = award.Name
|
|
resp.Awards[ix].Num = award.Num
|
|
resp.Awards[ix].Text = award.Text
|
|
resp.Awards[ix].WebUrl = award.WebUrl
|
|
resp.Awards[ix].MobileUrl = award.MobileUrl
|
|
resp.Awards[ix].Type = award.Type
|
|
resp.Awards[ix].Expire = award.Expire
|
|
if award.Usage != nil {
|
|
resp.Awards[ix].Usage = &v1pb.Usage{}
|
|
resp.Awards[ix].Usage.Text = award.Usage.Text
|
|
resp.Awards[ix].Usage.Url = award.Usage.Url
|
|
}
|
|
}
|
|
return
|
|
}
|