jager/novatask
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

增加软质押手动结算测试接口

Browse Source
This commit is contained in:
lianghuanjie
2025-01-08 11:41:11 +08:00
parent 9aae8bd4dd
commit e7a802efdb
24 changed files with 634 additions and 330 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
internal/logic/admin/nft_holder_update_logic.go Normal file
View File

@@ -0,0 +1,31 @@
package admin
import (
"context"
"nova_task/internal/logic/nft"
"nova_task/internal/pkg/errs"
"github.com/zeromicro/go-zero/core/logx"
"nova_task/internal/svc"
)
type NftHolderUpdateLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// NFT持有者更新
func NewNftHolderUpdateLogic(ctx context.Context, svcCtx *svc.ServiceContext) *NftHolderUpdateLogic {
return &NftHolderUpdateLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *NftHolderUpdateLogic) NftHolderUpdate() error {
lg := nft.NewHolderUpdateLogic(l.ctx, l.svcCtx)
lg.HolderUpdate()
return errs.Success()
}

30
internal/logic/admin/stake_settle_logic.go Normal file
View File

@@ -0,0 +1,30 @@
package admin
import (
"context"
"github.com/zeromicro/go-zero/core/logx"
"nova_task/internal/logic/nft"
"nova_task/internal/pkg/errs"
"nova_task/internal/svc"
)
type StakeSettleLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// 软质压手动结算
func NewStakeSettleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *StakeSettleLogic {
return &StakeSettleLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *StakeSettleLogic) StakeSettle() error {
lg := nft.NewStakeSettleLogic(l.ctx, l.svcCtx)
lg.StakeSettle()
return errs.Success()
}

41
internal/logic/carv/bind_wallet_logic.go
View File

@@ -2,6 +2,9 @@ package carv
import (
"context"
"errors"
"nova_task/internal/model"
"nova_task/internal/pkg/errs"
"nova_task/internal/svc"
"nova_task/internal/types"
@@ -24,8 +27,40 @@ func NewBindWalletLogic(ctx context.Context, svcCtx *svc.ServiceContext) *BindWa
}
}
func (l *BindWalletLogic) BindWallet(req *types.EmailKey) (resp *types.CarvResult, err error) {
l.svcCtx.UserModel.FindOneByEmail(l.ctx, req.Email)
func (l *BindWalletLogic) BindWallet(req *types.EmailKey) (*types.CarvResult, error) {
u, err := l.svcCtx.UserModel.FindOneByEmail(l.ctx, req.Email)
if err != nil {
if !errors.Is(err, model.ErrNotFound) {
return &types.CarvResult{
Error: &types.Error{
Code: int(errs.ErrDatabaseOperate),
Message: "system error",
},
}, nil
}
return &types.CarvResult{
Error: &types.Error{
Code: int(errs.ErrUserNotFound),
Message: "email not exist",
},
}, nil
}
return
_, err = l.svcCtx.WalletModel.FindAddressByUid(l.ctx, u.Id)
if err != nil {
if !errors.Is(err, model.ErrNotFound) {
return &types.CarvResult{
Error: &types.Error{
Code: int(errs.ErrDatabaseOperate),
Message: "system error",
},
}, nil
}
return &types.CarvResult{
Result: &types.Result{IsValid: false},
}, nil
}
return &types.CarvResult{
Result: &types.Result{IsValid: true},
}, nil
}

71
internal/logic/earn/data_report_logic.go Normal file
View File

@@ -0,0 +1,71 @@
package earn
import (
"context"
ea "github.com/earn-alliance/earnalliance-go"
"github.com/spf13/cast"
"github.com/zeromicro/go-zero/core/logx"
"nova_task/internal/svc"
)
type DataReportLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewDataReportLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DataReportLogic {
return &DataReportLogic{
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *DataReportLogic) PushUserInfo(shareId uint) {
us, err := l.svcCtx.PromoteBindModel.FindRequirePushUser(l.ctx, shareId)
if err != nil {
logx.Errorw("find require push user failed", logx.Field("err", err), logx.Field("share_id", shareId))
return
}
logx.Debugw("find require push user", logx.Field("count", len(us)))
for _, u := range us {
ui, err := l.svcCtx.UserModel.FindOne(l.ctx, u.InvitedUid)
if err != nil {
logx.Errorw("find user failed", logx.Field("err", err), logx.Field("uid", u.InvitedUid))
continue
}
var twitterId string
ut, err := l.svcCtx.TwitterModel.FindOne(l.ctx, u.InvitedUid)
if err == nil {
twitterId = ut.TwitterId
}
err = l.svcCtx.PromoteBindModel.UpdatePushUser(l.ctx, u.Id)
if err != nil {
logx.Errorw("update push user failed", logx.Field("err", err), logx.Field("uid", u.InvitedUid), logx.Field("twitter_id", twitterId), logx.Field("email", ui.Email))
} else {
l.svcCtx.Earn.SetIdentifiers(cast.ToString(ui.Id), &ea.Identifiers{
Email: ea.IdentifierFrom(ui.Email),
TwitterId: ea.IdentifierFrom(twitterId),
})
logx.Infow("push user info success", logx.Field("uid", u.InvitedUid), logx.Field("twitter_id", twitterId), logx.Field("email", ui.Email))
}
}
}
func (l *DataReportLogic) PushUserBind(shareId uint) {
us, err := l.svcCtx.TouristBindModel.FindRequirePushUser(l.ctx, shareId)
if err != nil {
logx.Errorw("find require push bind role user failed", logx.Field("err", err), logx.Field("share_id", shareId))
return
}
logx.Debugw("find require push bind role user", logx.Field("count", len(us)))
for _, u := range us {
err = l.svcCtx.PromoteBindModel.UpdatePushRole(l.ctx, u.Id)
if err != nil {
logx.Errorw("update push user failed", logx.Field("err", err), logx.Field("uid", u.Uid))
} else {
l.svcCtx.Earn.Track(cast.ToString(u.Uid), "BIND_ROLE", nil, nil)
logx.Infow("push user info success", logx.Field("uid", u.Uid))
}
}
}

158
internal/logic/nft/holder_update_logic.go Normal file
View File

@@ -0,0 +1,158 @@
package nft
import (
"context"
"encoding/json"
"errors"
"fmt"
"github.com/spf13/cast"
"github.com/zeromicro/go-zero/core/logx"
"net/http"
"nova_task/internal/consts"
"nova_task/internal/model"
"nova_task/internal/svc"
"time"
)
type HolderUpdateLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewHolderUpdateLogic(ctx context.Context, svcCtx *svc.ServiceContext) *HolderUpdateLogic {
return &HolderUpdateLogic{
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *HolderUpdateLogic) HolderUpdate() {
conf := struct {
Network string `json:"network"`
Contract string `json:"contract"`
}{}
cf, err := l.svcCtx.ConfigModel.FindOneByName(l.ctx, consts.NftHolderApiConf)
if err != nil {
logx.Errorw("find nft holder api conf error", logx.Field("error", err))
return
}
err = json.Unmarshal([]byte(cf.Value), &conf)
if err != nil {
logx.Errorw("unmarshal nft holder api conf error", logx.Field("error", err), logx.Field("value", cf.Value))
return
}
ols, err := l.GetOwnerList(conf.Network, conf.Contract)
if err != nil {
logx.Errorw("get owner list error", logx.Field("error", err))
return
}
updateSeq := int(time.Now().Unix())
for _, o := range ols.Owners {
for _, tk := range o.TokenBalances {
balance := cast.ToInt(tk.Balance)
logx.Debugw("owner token", logx.Field("address", o.OwnerAddress), logx.Field("token", tk.TokenID), logx.Field("balance", tk.Balance))
nft, err := l.svcCtx.NftHolderModel.FindOneByTokenId(l.ctx, tk.TokenID)
if err != nil {
if errors.Is(err, model.ErrNotFound) {
nft = &model.NhNftHolder{
Address: o.OwnerAddress,
TokenId: tk.TokenID,
Balance: balance,
UpdateSeq: updateSeq,
}
} else {
logx.Errorw("find nft holder error", logx.Field("error", err), logx.Field("address", o.OwnerAddress), logx.Field("token", tk.TokenID))
continue
}
}
var value int
if nft.Id == 0 {
// 新增
_, err = l.svcCtx.NftHolderModel.Insert(l.ctx, nft)
value = balance
} else {
// 持有数量变化
value = balance - nft.Balance
if value != 0 {
nft.Balance = balance
nft.UpdateSeq = updateSeq
err = l.svcCtx.NftHolderModel.Update(l.ctx, nft)
}
}
if err != nil {
logx.Errorw("insert or update nft holder error", logx.Field("error", err), logx.Field("address", o.OwnerAddress), logx.Field("token", tk.TokenID), logx.Field("balance", balance))
}
// 余额有变化，记录变化日志
if value != 0 {
_, err = l.svcCtx.NftHolderChangeLogModel.Insert(l.ctx, &model.NhNftHolderChangeLog{
Address: o.OwnerAddress,
TokenId: tk.TokenID,
Value: balance,
Balance: balance,
})
if err != nil {
logx.Errorw("insert nft holder change log error", logx.Field("error", err), logx.Field("address", o.OwnerAddress), logx.Field("token", tk.TokenID))
}
}
}
}
// 删除已经不持有的地址，且添加变化日志
nfts, err := l.svcCtx.NftHolderModel.FindOtherUpdateSeq(l.ctx, updateSeq)
if err != nil {
logx.Errorw("find other update seq error", logx.Field("error", err))
return
}
for _, nft := range nfts {
_, err = l.svcCtx.NftHolderChangeLogModel.Insert(l.ctx, &model.NhNftHolderChangeLog{
Address: nft.Address,
TokenId: nft.TokenId,
Value: -nft.Balance,
Balance: 0,
})
if err != nil {
logx.Errorw("delete nft holder error", logx.Field("error", err), logx.Field("address", nft.Address), logx.Field("token", nft.TokenId))
}
uid, err := l.svcCtx.WalletModel.FindUidByAddress(l.ctx, nft.Address)
if err != nil {
logx.Errorw("find uid by address error", logx.Field("error", err), logx.Field("address", nft.Address))
continue
}
err = l.svcCtx.StakeNftModel.UnStakeNft(l.ctx, uid, nft.TokenId, true)
if err != nil {
logx.Errorw("un stake nft error", logx.Field("error", err), logx.Field("address", nft.Address), logx.Field("token", nft.TokenId))
}
}
err = l.svcCtx.NftHolderModel.DeleteOtherUpdateSeq(l.ctx, updateSeq)
if err != nil {
logx.Errorw("delete other update seq error", logx.Field("error", err), logx.Field("update_seq", updateSeq))
}
}
type OwnerList struct {
Owners []struct {
OwnerAddress string `json:"ownerAddress"`
TokenBalances []struct {
TokenID string `json:"tokenId"`
Balance string `json:"balance"`
} `json:"tokenBalances"`
} `json:"owners"`
PageKey string `json:"pageKey"`
}
func (l *HolderUpdateLogic) GetOwnerList(network, contractAddress string) (*OwnerList, error) {
url := fmt.Sprintf("https://eth-%s.g.alchemy.com/nft/v3/alcht_1a183fAsPqF9upfTfp3AC1l0iedGLo/getOwnersForContract?contractAddress=%s&withTokenBalances=true", network, contractAddress)
resp, err := http.Get(url)
if err != nil {
return nil, err
}
defer resp.Body.Close()
result := new(OwnerList)
err = json.NewDecoder(resp.Body).Decode(result)
return result, err
}

114
internal/logic/nft/stake_settle_logic.go Normal file
View File

@@ -0,0 +1,114 @@
package nft
import (
"context"
"github.com/shopspring/decimal"
"github.com/spf13/cast"
"github.com/zeromicro/go-zero/core/logx"
"nova_task/internal/model"
"nova_task/internal/pkg/utils"
"nova_task/internal/svc"
"time"
)
type StakeSettleLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewStakeSettleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *StakeSettleLogic {
return &StakeSettleLogic{
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *StakeSettleLogic) StakeSettle() {
start, end, err := l.svcCtx.ConfigModel.GetNftStakeTaskOpenDate(l.ctx)
if err != nil {
logx.Errorw("get nft stake task open date failed", logx.Field("err", err))
return
}
end = end.AddDate(0, 0, 1).Add(-time.Second)
now := time.Now()
if now.Before(start) || now.After(end) {
logx.Infow("now is not in the date range", logx.Field("now", now), logx.Field("start", start), logx.Field("end", end))
return
}
taskConf, err := l.svcCtx.ConfigModel.GetNftStakeTaskConf(l.ctx)
if err != nil {
logx.Errorw("get nft stake task conf failed", logx.Field("err", err))
return
}
stakes, err := l.svcCtx.StakeNftModel.AllStakeNft(l.ctx)
if err != nil {
logx.Errorw("get all stake nft failed", logx.Field("err", err))
return
}
uid2tokens := map[uint]float64{}
for _, s := range stakes {
if s.State != 1 {
continue
}
nftHolder, err := l.svcCtx.NftHolderModel.FindOneByTokenId(l.ctx, s.TokenId)
if err != nil {
logx.Errorw("find nft holder failed", logx.Field("err", err), logx.Field("tokenId", s.TokenId))
continue
}
uid, err := l.svcCtx.WalletModel.FindUidByAddress(l.ctx, nftHolder.Address)
if err != nil {
logx.Errorw("find uid by address failed", logx.Field("err", err), logx.Field("address", nftHolder.Address))
continue
}
if uid != s.Uid {
logx.Errorw("uid not match", logx.Field("uid", s.Uid), logx.Field("nftHolderUid", uid))
continue
}
if utils.IsBigTarot(s.TokenId) {
uid2tokens[s.Uid] += float64(taskConf.GreatTarot)
} else {
uid2tokens[s.Uid] += float64(taskConf.LittleTarot)
}
}
awardSeq := cast.ToInt(time.Now().AddDate(0, 0, -1).Format("20060102"))
for uid, tokens := range uid2tokens {
coefficient, err := l.svcCtx.StakeRewardModel.GetRandomCoefficientByUid(l.ctx, uid, awardSeq, taskConf.MinCoefficient, taskConf.MaxCoefficient)
if err != nil {
logx.Errorw("get random coefficient failed", logx.Field("err", err), logx.Field("uid", uid), logx.Field("awardSeq", awardSeq))
continue
}
tokensDecimal := decimal.NewFromFloat(tokens)
reward := tokensDecimal.Mul(decimal.NewFromFloat(coefficient))
err = l.svcCtx.StakeRewardModel.SetReward(l.ctx, uid, awardSeq, taskConf.OccupyPercent, tokensDecimal, reward)
if err != nil {
logx.Errorw("set reward failed", logx.Field("err", err), logx.Field("uid", uid), logx.Field("awardSeq", awardSeq), logx.Field("coefficient", coefficient), logx.Field("tokens", tokens), logx.Field("reward", reward))
continue
}
// 加资产
err = l.svcCtx.TaskAssetModel.AddCastile(l.ctx, uid, reward)
if err != nil {
logx.Errorw("add castile failed", logx.Field("err", err), logx.Field("uid", uid), logx.Field("awardSeq", awardSeq), logx.Field("reward", reward))
continue
}
// 加资产记录表
_, err = l.svcCtx.TaskAssetRecordModel.Insert(l.ctx, &model.NhTaskAssetRecord{
Uid: int(uid),
EventId: 0,
AssetField: "castile",
Count: reward.InexactFloat64(),
Remark: "nft软质押奖励",
ProvideUid: 0,
CreateTime: int(now.Unix()),
})
if err != nil {
logx.Errorw("insert task asset record failed", logx.Field("err", err), logx.Field("uid", uid), logx.Field("awardSeq", awardSeq), logx.Field("reward", reward))
}
}
}

2
internal/logic/task/get_nft_list_logic.go
View File

@@ -48,7 +48,7 @@ func (l *GetNftListLogic) GetNftList(req *types.GetNftListReq) (*types.UserNftLi
var hasStake bool
var stakeAt string
var roleId uint64
nft, err := l.svcCtx.StakeNftModel.FindOneByUidTokenId(l.ctx, uid, token)
nft, err := l.svcCtx.StakeNftModel.FindOneByTokenId(l.ctx, token)
if err == nil {
hasStake = nft.State == 1
if hasStake {

67
internal/logic/task/stake_nft_logic.go
View File

@@ -40,37 +40,52 @@ func (l *StakeNftLogic) StakeNft(req *types.StakeNftList) error {
l.Errorw("find nft holder failed", logx.Field("err", err), logx.Field("uid", uid), logx.Field("tokenId", tokenId))
return errs.New(errs.ErrDatabaseOperate, err)
}
l.svcCtx.WalletModel.FindUidByAddress(l.ctx, tkHolder.Address)
err = l.svcCtx.StakeNftModel.StakeNft(l.ctx, uid, req.RoleId, tokenId)
wUid, err := l.svcCtx.WalletModel.FindUidByAddress(l.ctx, tkHolder.Address)
if err != nil {
if !errors.Is(err, model.ErrNotFound) {
l.Errorw("find wallet by address failed", logx.Field("err", err), logx.Field("uid", uid), logx.Field("address", tkHolder.Address))
return errs.New(errs.ErrDatabaseOperate, err)
}
return errs.New(errs.ErrNftNotBelongToUser, "nft not belong to user")
}
if wUid != uid {
l.Errorw("nft not belong to user", logx.Field("uid", uid), logx.Field("address", tkHolder.Address))
return errs.New(errs.ErrNftNotBelongToUser, "nft not belong to user")
}
var sns []int8
var propertyId string
var tarotType int8
if utils.IsBigTarot(tokenId) {
sns = []int8{1, 2}
propertyId = "402505"
tarotType = 1
} else {
sns = []int8{1}
propertyId = "402605"
}
err = l.svcCtx.StakeNftModel.StakeNft(l.ctx, uid, req.RoleId, tokenId, tarotType)
if err != nil {
l.Errorw("stake nft failed", logx.Field("err", err), logx.Field("uid", uid), logx.Field("tokenIds", req.TokenIds))
return errs.New(errs.ErrDatabaseOperate, err)
}
var sns []int8
var propertyId string
if utils.IsBigTarot(tokenId) {
sns = []int8{1, 2}
propertyId = "402505"
} else {
sns = []int8{1}
propertyId = "402605"
}
for _, sn := range sns {
_, err = l.svcCtx.StakePropertyModel.Insert(l.ctx, &model.NhNftStakeProperty{
Uid: uid,
RoleId: int64(req.RoleId),
TokenId: cast.ToUint(tokenId),
PropertyId: propertyId,
Sn: sn,
})
if err != nil {
errMySQL := new(mysql.MySQLError)
if errors.As(err, &errMySQL) {
switch errMySQL.Number {
case 1062:
default:
l.Errorw("insert stake property failed", logx.Field("err", err), logx.Field("uid", uid), logx.Field("tokenId", tokenId), logx.Field("propertyId", propertyId))
if req.RoleId > 0 {
for _, sn := range sns {
_, err = l.svcCtx.StakePropertyModel.Insert(l.ctx, &model.NhNftStakeProperty{
Uid: uid,
RoleId: int64(req.RoleId),
TokenId: cast.ToUint(tokenId),
PropertyId: propertyId,
Sn: sn,
})
if err != nil {
errMySQL := new(mysql.MySQLError)
if errors.As(err, &errMySQL) {
switch errMySQL.Number {
case 1062:
default:
l.Errorw("insert stake property failed", logx.Field("err", err), logx.Field("uid", uid), logx.Field("tokenId", tokenId), logx.Field("propertyId", propertyId))
}
}
}
}