openbilibili/app/admin/live/live-admin/service/v1/capsule.go

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
}