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.
547 lines
16 KiB
547 lines
16 KiB
package v1 |
|
|
|
import ( |
|
"context" |
|
"encoding/json" |
|
"go-common/library/ecode" |
|
"regexp" |
|
"strconv" |
|
"strings" |
|
"time" |
|
|
|
"google.golang.org/grpc/status" |
|
|
|
v1pb "go-common/app/admin/live/live-admin/api/http/v1" |
|
"go-common/app/admin/live/live-admin/conf" |
|
rspb "go-common/app/service/live/xlottery/api/grpc/v1" |
|
"go-common/library/log" |
|
) |
|
|
|
// CapsuleService struct |
|
type CapsuleService struct { |
|
conf *conf.Config |
|
// optionally add other properties here, such as dao |
|
// dao *dao.Dao |
|
capsuleCli *rspb.Client |
|
} |
|
|
|
//NewCapsuleService init |
|
func NewCapsuleService(c *conf.Config) (s *CapsuleService) { |
|
s = &CapsuleService{ |
|
conf: c, |
|
} |
|
var svc *rspb.Client |
|
var err error |
|
log.Info("CapsuleService Init: %+v", s.conf.CapsuleClient) |
|
if svc, err = rspb.NewClient(s.conf.CapsuleClient); err != nil { |
|
panic(err) |
|
} |
|
s.capsuleCli = svc |
|
return s |
|
} |
|
|
|
// GetCoinList implementation |
|
func (s *CapsuleService) GetCoinList(ctx context.Context, req *v1pb.GetCoinListReqAdmin) (resp *v1pb.GetCoinListRespAdmin, err error) { |
|
var RPCResponse *rspb.GetCoinListResp |
|
RPCReq := &rspb.GetCoinListReq{ |
|
Page: req.Page, |
|
PageSize: req.PageSize, |
|
} |
|
if RPCReq.Page < 1 { |
|
RPCReq.Page = 1 |
|
} |
|
if RPCReq.PageSize < 1 { |
|
RPCReq.PageSize = 16 |
|
} |
|
|
|
RPCResponse, err = s.capsuleCli.GetCoinList(ctx, RPCReq) |
|
if err != nil { |
|
return |
|
} |
|
coinListResp := make([]*v1pb.GetCoinListRespAdmin_List, 0) |
|
for _, singleCoinList := range RPCResponse.List { |
|
coinList := &v1pb.GetCoinListRespAdmin_List{} |
|
coinList.Id = singleCoinList.Id |
|
coinList.Status = singleCoinList.Status |
|
coinList.Title = singleCoinList.Title |
|
coinList.GiftConfig = singleCoinList.GiftConfig |
|
coinList.GiftType = singleCoinList.GiftType |
|
coinList.ChangeNum = singleCoinList.ChangeNum |
|
startTimeUnix := time.Unix(singleCoinList.StartTime, 0) |
|
coinList.StartTime = startTimeUnix.Format("2006-01-02 15:04:05") |
|
endTimeUnix := time.Unix(singleCoinList.EndTime, 0) |
|
coinList.EndTime = endTimeUnix.Format("2006-01-02 15:04:05") |
|
areaIds := make([]*v1pb.GetCoinListRespAdmin_List_AreaIds, 0) |
|
for _, areaId := range singleCoinList.AreaIds { |
|
singleAreaId := &v1pb.GetCoinListRespAdmin_List_AreaIds{} |
|
singleAreaId.IsAll = areaId.IsAll |
|
singleAreaId.List = areaId.List |
|
singleAreaId.ParentId = areaId.ParentId |
|
areaIds = append(areaIds, singleAreaId) |
|
} |
|
coinList.AreaIds = areaIds |
|
coinListResp = append(coinListResp, coinList) |
|
} |
|
resp = &v1pb.GetCoinListRespAdmin{ |
|
Total: RPCResponse.Total, |
|
TotalPage: RPCResponse.TotalPage, |
|
List: coinListResp, |
|
} |
|
return |
|
} |
|
|
|
// UpdateCoinConfig implementation |
|
func (s *CapsuleService) UpdateCoinConfig(ctx context.Context, req *v1pb.UpdateCoinConfigReqAdmin) (resp *v1pb.UpdateCoinConfigRespAdmin, err error) { |
|
var RPCResponse *rspb.UpdateCoinConfigResp |
|
|
|
loc, _ := time.LoadLocation("Local") |
|
var endTime, startTime time.Time |
|
startTime, err = time.ParseInLocation("2006-01-02 15:04:05", req.StartTime, loc) |
|
if err != nil { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return nil, err |
|
} |
|
endTime, err = time.ParseInLocation("2006-01-02 15:04:05", req.EndTime, loc) |
|
if err != nil { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return nil, err |
|
} |
|
var areaIds []*rspb.UpdateCoinConfigReq_AreaIds |
|
err = json.Unmarshal([]byte(req.AreaIds), &areaIds) |
|
if err != nil { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return nil, err |
|
} |
|
if len(areaIds) == 0 { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return nil, err |
|
} |
|
var isHasArea bool |
|
for _, areaInfo := range areaIds { |
|
if areaInfo.IsAll == 1 { |
|
isHasArea = true |
|
break |
|
} |
|
if len(areaInfo.List) > 0 { |
|
isHasArea = true |
|
break |
|
} |
|
} |
|
if !isHasArea { |
|
err = ecode.Error(ecode.XLotteryCapsuleAreaParamErr, "必须设置生效分区") |
|
return nil, err |
|
} |
|
var giftIds = make([]int64, 0) |
|
if req.GiftType == 3 { |
|
if req.GiftConfig == "" { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return nil, err |
|
} |
|
giftConfig := strings.Split(req.GiftConfig, ",") |
|
for _, giftStr := range giftConfig { |
|
var giftId int64 |
|
giftId, err = strconv.ParseInt(giftStr, 10, 64) |
|
if err != nil { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return nil, err |
|
} |
|
giftIds = append(giftIds, giftId) |
|
} |
|
if len(giftIds) == 0 { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return nil, err |
|
} |
|
match, _ := regexp.Compile("^([0-9]+,)*[0-9]+$") |
|
if !match.MatchString(req.GiftConfig) { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return nil, err |
|
} |
|
} |
|
RPCReq := &rspb.UpdateCoinConfigReq{ |
|
Id: req.Id, |
|
Title: req.Title, |
|
ChangeNum: req.ChangeNum, |
|
StartTime: startTime.Unix(), |
|
EndTime: endTime.Unix(), |
|
Status: req.Status, |
|
GiftType: req.GiftType, |
|
GiftIds: giftIds, |
|
AreaIds: areaIds, |
|
} |
|
RPCResponse, err = s.capsuleCli.UpdateCoinConfig(ctx, RPCReq) |
|
if err != nil { |
|
return |
|
} |
|
resp = &v1pb.UpdateCoinConfigRespAdmin{ |
|
Status: RPCResponse.Status, |
|
} |
|
return |
|
} |
|
|
|
// UpdateCoinStatus implementation |
|
func (s *CapsuleService) UpdateCoinStatus(ctx context.Context, req *v1pb.UpdateCoinStatusReqAdmin) (resp *v1pb.UpdateCoinStatusRespAdmin, err error) { |
|
var RPCResponse *rspb.UpdateCoinStatusResp |
|
RPCReq := &rspb.UpdateCoinStatusReq{ |
|
Id: req.Id, |
|
Status: req.Status, |
|
} |
|
if RPCReq.Status != 1 { |
|
RPCReq.Status = 0 |
|
} |
|
RPCResponse, err = s.capsuleCli.UpdateCoinStatus(ctx, RPCReq) |
|
if err != nil { |
|
return |
|
} |
|
resp = &v1pb.UpdateCoinStatusRespAdmin{ |
|
Status: RPCResponse.Status, |
|
} |
|
return |
|
} |
|
|
|
// DeleteCoin implementation |
|
func (s *CapsuleService) DeleteCoin(ctx context.Context, req *v1pb.DeleteCoinReqAdmin) (resp *v1pb.DeleteCoinRespAdmin, err error) { |
|
var RPCResponse *rspb.DeleteCoinResp |
|
RPCReq := &rspb.DeleteCoinReq{ |
|
Id: req.Id, |
|
} |
|
RPCResponse, err = s.capsuleCli.DeleteCoin(ctx, RPCReq) |
|
if err != nil { |
|
return |
|
} |
|
resp = &v1pb.DeleteCoinRespAdmin{ |
|
Status: RPCResponse.Status, |
|
} |
|
return |
|
} |
|
|
|
// GetPoolList implementation |
|
// `internal:"true"` |
|
func (s *CapsuleService) GetPoolList(ctx context.Context, req *v1pb.GetPoolListReqAdmin) (resp *v1pb.GetPoolListRespAdmin, err error) { |
|
var RPCResponse *rspb.GetPoolListResp |
|
RPCReq := &rspb.GetPoolListReq{ |
|
Page: req.Page, |
|
PageSize: req.PageSize, |
|
} |
|
if RPCReq.Page < 1 { |
|
RPCReq.Page = 1 |
|
} |
|
if RPCReq.PageSize < 1 { |
|
RPCReq.PageSize = 16 |
|
} |
|
RPCResponse, err = s.capsuleCli.GetPoolList(ctx, RPCReq) |
|
if err != nil { |
|
return |
|
} |
|
poolList := make([]*v1pb.GetPoolListRespAdmin_List, 0) |
|
for _, singleList := range RPCResponse.List { |
|
poolInfo := &v1pb.GetPoolListRespAdmin_List{} |
|
poolInfo.Id = singleList.Id |
|
startTimeUnix := time.Unix(singleList.StartTime, 0) |
|
poolInfo.StartTime = startTimeUnix.Format("2006-01-02 15:04:05") |
|
endTimeUnix := time.Unix(singleList.EndTime, 0) |
|
poolInfo.EndTime = endTimeUnix.Format("2006-01-02 15:04:05") |
|
poolInfo.Title = singleList.Title |
|
poolInfo.CoinTitle = singleList.CoinTitle |
|
poolInfo.Status = singleList.Status |
|
poolInfo.Rule = singleList.Rule |
|
poolInfo.CoinId = singleList.CoinId |
|
poolList = append(poolList, poolInfo) |
|
} |
|
resp = &v1pb.GetPoolListRespAdmin{ |
|
Total: RPCResponse.Total, |
|
TotalPage: RPCResponse.TotalPage, |
|
List: poolList, |
|
} |
|
return |
|
} |
|
|
|
// UpdatePool implementation |
|
// `method:"POST" internal:"true"` |
|
func (s *CapsuleService) UpdatePool(ctx context.Context, req *v1pb.UpdatePoolReqAdmin) (resp *v1pb.UpdatePoolRespAdmin, err error) { |
|
var RPCResponse *rspb.UpdatePoolResp |
|
loc, _ := time.LoadLocation("Local") |
|
startTime, err := time.ParseInLocation("2006-01-02 15:04:05", req.StartTime, loc) |
|
if err != nil { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return nil, err |
|
} |
|
endTime, err := time.ParseInLocation("2006-01-02 15:04:05", req.EndTime, loc) |
|
if err != nil { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return nil, err |
|
} |
|
RPCReq := &rspb.UpdatePoolReq{ |
|
Id: req.Id, |
|
CoinId: req.CoinId, |
|
Title: req.Title, |
|
StartTime: startTime.Unix(), |
|
EndTime: endTime.Unix(), |
|
Rule: req.Rule, |
|
} |
|
RPCResponse, err = s.capsuleCli.UpdatePool(ctx, RPCReq) |
|
if err != nil { |
|
return |
|
} |
|
resp = &v1pb.UpdatePoolRespAdmin{ |
|
Status: RPCResponse.Status, |
|
} |
|
return |
|
} |
|
|
|
// DeletePool implementation |
|
func (s *CapsuleService) DeletePool(ctx context.Context, req *v1pb.DeletePoolReqAdmin) (resp *v1pb.DeletePoolRespAdmin, err error) { |
|
var RPCResponse *rspb.DeletePoolResp |
|
RPCReq := &rspb.DeletePoolReq{ |
|
Id: req.Id, |
|
} |
|
RPCResponse, err = s.capsuleCli.DeletePool(ctx, RPCReq) |
|
if err != nil { |
|
return |
|
} |
|
resp = &v1pb.DeletePoolRespAdmin{ |
|
Status: RPCResponse.Status, |
|
} |
|
|
|
return |
|
} |
|
|
|
// UpdatePoolStatus implementation |
|
func (s *CapsuleService) UpdatePoolStatus(ctx context.Context, req *v1pb.UpdatePoolStatusReqAdmin) (resp *v1pb.UpdatePoolStatusRespAdmin, err error) { |
|
resp = &v1pb.UpdatePoolStatusRespAdmin{} |
|
data, err := s.capsuleCli.UpdatePoolStatus(ctx, &rspb.UpdatePoolStatusReq{Id: req.Id, Status: req.Status}) |
|
if err != nil { |
|
return |
|
} |
|
resp.Status = data.Status |
|
return |
|
} |
|
|
|
// GetPoolPrize implementation |
|
// `internal:"true"` |
|
func (s *CapsuleService) GetPoolPrize(ctx context.Context, req *v1pb.GetPoolPrizeReqAdmin) (resp *v1pb.GetPoolPrizeRespAdmin, err error) { |
|
var RPCResponse *rspb.GetPoolPrizeResp |
|
RPCReq := &rspb.GetPoolPrizeReq{ |
|
PoolId: req.PoolId, |
|
} |
|
RPCResponse, err = s.capsuleCli.GetPoolPrize(ctx, RPCReq) |
|
if err != nil { |
|
return |
|
} |
|
list := make([]*v1pb.GetPoolPrizeRespAdmin_List, 0) |
|
for _, poolDetail := range RPCResponse.List { |
|
singleDetail := &v1pb.GetPoolPrizeRespAdmin_List{} |
|
singleDetail.Id = poolDetail.Id |
|
singleDetail.Limit = poolDetail.Limit |
|
singleDetail.Loop = poolDetail.Loop |
|
singleDetail.Chance = poolDetail.Chance |
|
singleDetail.ProType = poolDetail.ProType |
|
singleDetail.JumpUrl = poolDetail.JumpUrl |
|
singleDetail.Description = poolDetail.Description |
|
singleDetail.MobileUrl = poolDetail.MobileUrl |
|
singleDetail.WebUrl = poolDetail.WebUrl |
|
singleDetail.Num = poolDetail.Num |
|
singleDetail.Type = poolDetail.Type |
|
singleDetail.ObjectId = poolDetail.ObjectId |
|
singleDetail.Expire = poolDetail.Expire |
|
singleDetail.PoolId = poolDetail.PoolId |
|
singleDetail.Name = poolDetail.Name |
|
singleDetail.Weight = poolDetail.Weight |
|
singleDetail.WhiteUids = "" |
|
wlen := len(poolDetail.WhiteUids) |
|
if wlen > 0 { |
|
wUids := make([]string, wlen) |
|
for ix, uid := range poolDetail.WhiteUids { |
|
wUids[ix] = strconv.FormatInt(uid, 10) |
|
} |
|
singleDetail.WhiteUids = strings.Join(wUids, ",") |
|
} |
|
list = append(list, singleDetail) |
|
} |
|
resp = &v1pb.GetPoolPrizeRespAdmin{ |
|
List: list, |
|
} |
|
return |
|
} |
|
|
|
// UpdatePoolPrize implementation |
|
// `method:"POST" internal:"true"` |
|
func (s *CapsuleService) UpdatePoolPrize(ctx context.Context, req *v1pb.UpdatePoolPrizeReqAdmin) (resp *v1pb.UpdatePoolPrizeRespAdmin, err error) { |
|
chance, err := strconv.ParseFloat(req.Chance, 64) |
|
if err != nil || chance > 1 { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return |
|
} |
|
chance = chance*10000 + 0.5 |
|
whiteUids := make([]int64, 0) |
|
if req.ProType == 1 { |
|
if chance < 1 { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return |
|
} |
|
req.Loop = 0 |
|
req.Limit = 0 |
|
} else if req.ProType == 2 { |
|
chance = 0 |
|
if req.Loop < 1 || req.Limit < 1 { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return |
|
} |
|
} else if req.ProType == 3 { |
|
chance = 0 |
|
if req.Loop < 1 || req.Limit < 1 { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return |
|
} |
|
} else if req.ProType == 4 { |
|
chance = 0 |
|
req.Loop = 0 |
|
req.Limit = 0 |
|
if req.WhiteUids == "" { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return |
|
} |
|
wUids := strings.Split(req.WhiteUids, ",") |
|
for _, uidStr := range wUids { |
|
var uid int64 |
|
uid, err = strconv.ParseInt(uidStr, 10, 64) |
|
if err != nil { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return nil, err |
|
} |
|
whiteUids = append(whiteUids, uid) |
|
} |
|
wlen := len(whiteUids) |
|
if wlen == 0 || wlen > 1000 { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return nil, err |
|
} |
|
} else { |
|
err = ecode.Error(ecode.InvalidParam, "参数错误") |
|
return |
|
} |
|
var RPCResponse *rspb.UpdatePoolPrizeResp |
|
RPCReq := &rspb.UpdatePoolPrizeReq{ |
|
Id: req.Id, |
|
PoolId: req.PoolId, |
|
Type: req.Type, |
|
Num: req.Num, |
|
ObjectId: req.ObjectId, |
|
Expire: req.Expire, |
|
WebUrl: req.WebUrl, |
|
MobileUrl: req.MobileUrl, |
|
Description: req.Description, |
|
JumpUrl: req.JumpUrl, |
|
ProType: req.ProType, |
|
Chance: int64(chance), |
|
Loop: req.Loop, |
|
Limit: req.Limit, |
|
Weight: req.Weight, |
|
WhiteUids: whiteUids, |
|
} |
|
RPCResponse, err = s.capsuleCli.UpdatePoolPrize(ctx, RPCReq) |
|
if err != nil { |
|
return |
|
} |
|
resp = &v1pb.UpdatePoolPrizeRespAdmin{ |
|
Status: RPCResponse.Status, |
|
PrizeId: RPCResponse.PrizeId, |
|
} |
|
return |
|
} |
|
|
|
// DeletePoolPrize implementation |
|
// `method:"POST" internal:"true" ` |
|
func (s *CapsuleService) DeletePoolPrize(ctx context.Context, req *v1pb.DeletePoolPrizeReqAdmin) (resp *v1pb.DeletePoolPrizeRespAdmin, err error) { |
|
var RPCResponse *rspb.DeletePoolPrizeResp |
|
RPCReq := &rspb.DeletePoolPrizeReq{ |
|
Id: req.Id, |
|
} |
|
RPCResponse, err = s.capsuleCli.DeletePoolPrize(ctx, RPCReq) |
|
if err != nil { |
|
return |
|
} |
|
resp = &v1pb.DeletePoolPrizeRespAdmin{ |
|
Status: RPCResponse.Status, |
|
} |
|
return |
|
} |
|
|
|
// GetPrizeType implementation |
|
// `internal:"true"` |
|
func (s *CapsuleService) GetPrizeType(ctx context.Context, req *v1pb.GetPrizeTypeReq) (resp *v1pb.GetPrizeTypeResp, err error) { |
|
resp = &v1pb.GetPrizeTypeResp{} |
|
prizeType, err := s.capsuleCli.GetPrizeType(ctx, &rspb.GetPrizeTypeReq{}) |
|
if err != nil || prizeType == nil { |
|
return |
|
} |
|
resp.List = make([]*v1pb.GetPrizeTypeResp_List, len(prizeType.List)) |
|
for ix, data := range prizeType.List { |
|
resp.List[ix] = &v1pb.GetPrizeTypeResp_List{Type: data.Type, Name: data.Name} |
|
} |
|
return |
|
} |
|
|
|
// GetPrizeExpire implementation |
|
// `internal:"true"` |
|
func (s *CapsuleService) GetPrizeExpire(ctx context.Context, req *v1pb.GetPrizeExpireReq) (resp *v1pb.GetPrizeExpireResp, err error) { |
|
resp = &v1pb.GetPrizeExpireResp{} |
|
prizeExpire, err := s.capsuleCli.GetPrizeExpire(ctx, &rspb.GetPrizeExpireReq{}) |
|
if err != nil || prizeExpire == nil { |
|
return |
|
} |
|
resp.List = make([]*v1pb.GetPrizeExpireResp_List, len(prizeExpire.List)) |
|
for ix, data := range prizeExpire.List { |
|
resp.List[ix] = &v1pb.GetPrizeExpireResp_List{Expire: data.Expire, Name: data.Name} |
|
} |
|
return |
|
} |
|
|
|
// FormatErr format error msg |
|
func (s *CapsuleService) FormatErr(statusCode *status.Status) (code int32, msg string) { |
|
gCode := statusCode.Code() |
|
code = 1 |
|
if gCode == 2 { |
|
code, _ := strconv.Atoi(statusCode.Message()) |
|
|
|
switch code { |
|
case -400: |
|
msg = "参数错误" |
|
case -401: |
|
msg = "上线失败，概率设置不为1" |
|
case -402: |
|
msg = "保底奖池的上下线时间不可修改" |
|
case -403: |
|
msg = "保底奖池不可下线" |
|
case -404: |
|
msg = "普通扭蛋币不可更改道具类型" |
|
case -500: |
|
msg = "内部错误" |
|
default: |
|
msg = "内部错误" |
|
} |
|
} else { |
|
msg = "内部错误" |
|
} |
|
return |
|
} |
|
|
|
// GetCouponList implementation |
|
// `internal:"true"` |
|
func (s *CapsuleService) GetCouponList(ctx context.Context, req *v1pb.CapsuleGetCouponListReq) (resp *v1pb.CapsuleGetCouponListResp, err error) { |
|
resp = &v1pb.CapsuleGetCouponListResp{} |
|
couponList, err := s.capsuleCli.GetCouponList(ctx, &rspb.CapsuleGetCouponListReq{Uid: req.Uid}) |
|
if err != nil || couponList == nil { |
|
return |
|
} |
|
resp.List = make([]*v1pb.CapsuleGetCouponListResp_List, len(couponList.List)) |
|
for ix, conpon := range couponList.List { |
|
resp.List[ix] = &v1pb.CapsuleGetCouponListResp_List{} |
|
resp.List[ix].Uid = req.Uid |
|
resp.List[ix].Status = conpon.Status |
|
resp.List[ix].AwardTime = conpon.AwardTime |
|
resp.List[ix].RetryTime = conpon.RetryTime |
|
resp.List[ix].AwardName = conpon.AwardName |
|
resp.List[ix].AwardCode = conpon.AwardCode |
|
} |
|
return |
|
}
|
|
|