You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
321 lines
10 KiB
321 lines
10 KiB
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 |
|
}
|
|
|