update 添加假数据

game/game_cluster/nodes/logstash/fakedata/asset.go

@@ -0,0 +1,91 @@
+package main
+
+import (
+	"fmt"
+	"math/rand"
+
+	"github.com/mhaya/game/game_cluster/internal/constant"
+	"github.com/mhaya/game/game_cluster/internal/mdb/eventmodels"
+	"gorm.io/gorm"
+)
+
+func getAssetFakeData(users []*eventmodels.UserBasic) []*eventmodels.AssetsEventContent {
+	datas := make([]*eventmodels.AssetsEventContent, 0, 8)
+
+	for i := 0; i < count; i++ {
+		userBasic := getUserBasic(users)
+		eventBasic := getEventBasic()
+
+		operation_type := func() string {
+			if rand.Intn(2) == 1 {
+				return string(constant.IncreaseOp)
+			}
+			return string(constant.DecreaseOp)
+		}
+		currency := func() string {
+			index := rand.Intn(3)
+			if index == 1 {
+				return string(constant.PointsCurrency)
+			}
+			if index == 2 {
+				return string(constant.TonCurrency)
+			}
+			return string(constant.UsdtCurrency)
+		}
+		reason := func() string {
+			if rand.Intn(2) == 1 {
+				return "reason"
+			}
+			return ""
+		}
+		var before_balance int64
+		var amount int64
+		var after_balance int64
+		before_balance = rand.Int63n(100000)
+		amount = rand.Int63n(1000)
+		after_balance = before_balance + amount
+
+		datas = append(datas, &eventmodels.AssetsEventContent{
+			UserBasic:     *userBasic,
+			EventBasic:    *eventBasic,
+			OperationType: operation_type(),
+			Currency:      currency(),
+			Reason:        reason(),
+			BeforeBalance: before_balance,
+			Amount:        amount,
+			AfterBalance:  after_balance,
+		})
+	}
+
+	return datas
+}
+
+func sumData(db *gorm.DB, users []*eventmodels.UserBasic) {
+	// sqlStr := `select SUM(amount) as total_amount from assets_event_contents where user_id = ? and currency = ?`
+	var total_amount int64
+	for _, nameObj := range users {
+		// err := db.Raw(sqlStr, name, "USDT").Pluck("SUM(amount) as total_amount", &total_amount).Error
+		// if err != nil {
+		// 	fmt.Printf("Pluck error:%v", err)
+		// 	return
+		// }
+
+		where := &eventmodels.AssetsEventContent{
+			UserBasic: eventmodels.UserBasic{
+				UserId: nameObj.UserId,
+				// UserId: "1", // 不存在的用户
+			},
+			EventBasic: eventmodels.EventBasic{
+				ServerId: server_id,
+			},
+			Currency: "USDT",
+		}
+		err := db.Model(&eventmodels.AssetsEventContent{}).Where(where).Pluck("SUM(amount) as total_amount", &total_amount).Error
+		if err != nil {
+			fmt.Printf("Pluck error:%v", err)
+			return
+		}
+
+		fmt.Printf("User_id:%s total_amount:%v", nameObj.UserId, total_amount)
+	}
+}

game/game_cluster/nodes/logstash/fakedata/dice.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"math/rand"
+
+	"github.com/mhaya/game/game_cluster/internal/mdb/eventmodels"
+)
+
+func getDiceFakeData(users []*eventmodels.UserBasic) []*eventmodels.DiceEventContent {
+	datas := make([]*eventmodels.DiceEventContent, 0, 8)
+
+	for i := 0; i < count; i++ {
+		userBasic := getUserBasic(users)
+		eventBasic := getEventBasic()
+
+		datas = append(datas, &eventmodels.DiceEventContent{
+			UserBasic:  *userBasic,
+			EventBasic: *eventBasic,
+			Count:      rand.Intn(50) + 1,
+		})
+	}
+
+	return datas
+}

game/game_cluster/nodes/logstash/fakedata/follow.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"math/rand"
+
+	"github.com/mhaya/game/game_cluster/internal/constant"
+	"github.com/mhaya/game/game_cluster/internal/mdb/eventmodels"
+)
+
+func getFollowFakeData(users []*eventmodels.UserBasic) []*eventmodels.FollowEventContent {
+	datas := make([]*eventmodels.FollowEventContent, 0, 8)
+
+	for i := 0; i < count; i++ {
+		userBasic := getUserBasic(users)
+		eventBasic := getEventBasic()
+
+		datas = append(datas, &eventmodels.FollowEventContent{
+			UserBasic:  *userBasic,
+			EventBasic: *eventBasic,
+			ChannelName: func() string {
+				if rand.Intn(2) == 1 {
+					return string(constant.TwitterFollowName)
+				}
+				return string(constant.YoutubeFollowName)
+			}(),
+		})
+	}
+
+	return datas
+}

game/game_cluster/nodes/logstash/fakedata/invite.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"math/rand"
+
+	"github.com/mhaya/game/game_cluster/internal/mdb/eventmodels"
+)
+
+func getInviteFakeData(users []*eventmodels.UserBasic) []*eventmodels.InviteEventContent {
+	datas := make([]*eventmodels.InviteEventContent, 0, 8)
+
+	for i := 0; i < count; i++ {
+		userBasic := getUserBasic(users)
+		eventBasic := getEventBasic()
+
+		invite := getUserBasic(users)
+
+		datas = append(datas, &eventmodels.InviteEventContent{
+			UserBasic:                 *userBasic,
+			EventBasic:                *eventBasic,
+			Platform:                  getPlatform(),
+			Channel:                   getChannel(),
+			InviteUserId:              invite.UserId,
+			IfInviteUserTgVip:         invite.IfTgVip,
+			InviteUserLevel2:          invite.Level,
+			ContinuousInviteUserCount: rand.Intn(50) + 1,
+		})
+	}
+
+	return datas
+}

game/game_cluster/nodes/logstash/fakedata/join.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"math/rand"
+
+	"github.com/mhaya/game/game_cluster/internal/constant"
+	"github.com/mhaya/game/game_cluster/internal/mdb/eventmodels"
+)
+
+func getJoinFakeData(users []*eventmodels.UserBasic) []*eventmodels.JoinChannelEventContent {
+	datas := make([]*eventmodels.JoinChannelEventContent, 0, 8)
+
+	for i := 0; i < count; i++ {
+		userBasic := getUserBasic(users)
+		eventBasic := getEventBasic()
+
+		datas = append(datas, &eventmodels.JoinChannelEventContent{
+			UserBasic:  *userBasic,
+			EventBasic: *eventBasic,
+			ChannelName: func() string {
+				if rand.Intn(2) == 1 {
+					return string(constant.TGJoinName)
+				}
+				return string(constant.DCJoinName)
+			}(),
+		})
+	}
+
+	return datas
+}

game/game_cluster/nodes/logstash/fakedata/login.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"math/rand"
+
+	"github.com/bxcodec/faker/v3"
+	"github.com/mhaya/game/game_cluster/internal/mdb/eventmodels"
+)
+
+func getLoginFakeData(users []*eventmodels.UserBasic) []*eventmodels.UserLoginEventContent {
+	datas := make([]*eventmodels.UserLoginEventContent, 0, 8)
+
+	for i := 0; i < count; i++ {
+		userBasic := getUserBasic(users)
+		eventBasic := getEventBasic()
+
+		datas = append(datas, &eventmodels.UserLoginEventContent{
+			UserBasic:         *userBasic,
+			EventBasic:        *eventBasic,
+			Ip:                faker.IPv4(),
+			Platform:          getPlatform(),
+			Channel:           getChannel(),
+			ContinuousDays:    rand.Intn(365) + 1,
+			ContinuousDaysMax: rand.Intn(365) + 1,
+		})
+	}
+
+	return datas
+}

game/game_cluster/nodes/logstash/fakedata/main.go

@@ -19,14 +19,122 @@ import (
 //                                    currency, reason, before_balance, amount, after_balance, server_id)
 // values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
 
-type NameData struct {
-	User_id   string
-	User_name string
-	Tg_id     string
-	X_id      string
-}
+var (
+	server_id = "m-web-admin-1"
+	count     = 100
+)
 
 func main() {
+	db := connectDb()
+
+	// address := faker.Address()
+	// phone := faker.Phone()
+	users := make([]*eventmodels.UserBasic, 0, 8)
+	for i := 0; i < 10; i++ {
+		user_id := faker.Name()
+		name := faker.Name()
+		tg_id := faker.Name()
+		x_id := faker.Name()
+		nameObj := &eventmodels.UserBasic{
+			UserId:   user_id,
+			UserName: name,
+			TgId:     tg_id,
+			XId:      x_id,
+			IsRobot:  false,
+			IfTgVip: func() bool {
+				return rand.Intn(2) == 1
+			}(),
+			TonWall:           faker.Name(),
+			Email:             faker.Email(),
+			Fingerprint:       faker.Name(),
+			Level:             rand.Intn(50) + 1,
+			UserStatus:        rand.Intn(2) + 1,
+			PointsRankSeq:     rand.Int63n(100) + 1,
+			ThrowDiceRankSeq:  rand.Int63n(100) + 1,
+			InviteUserRankSeq: rand.Int63n(100) + 1,
+		}
+		users = append(users, nameObj)
+	}
+
+	registerDatas := getregisterFakeData(users)
+	err := db.CreateInBatches(registerDatas, len(registerDatas)).Error
+	if err != nil {
+		fmt.Printf("CreateInBatches registerDatas error:%v", err)
+		return
+	}
+
+	updateDatas := getUpdateInfoFakeData(users)
+	err = db.CreateInBatches(updateDatas, len(updateDatas)).Error
+	if err != nil {
+		fmt.Printf("CreateInBatches updateDatas error:%v", err)
+		return
+	}
+
+	assetDatas := getAssetFakeData(users)
+	err = db.CreateInBatches(assetDatas, len(assetDatas)).Error
+	if err != nil {
+		fmt.Printf("CreateInBatches assetDatas error:%v", err)
+		return
+	}
+
+	diceDatas := getDiceFakeData(users)
+	err = db.CreateInBatches(diceDatas, len(diceDatas)).Error
+	if err != nil {
+		fmt.Printf("CreateInBatches diceDatas error:%v", err)
+		return
+	}
+
+	followDatas := getFollowFakeData(users)
+	err = db.CreateInBatches(followDatas, len(followDatas)).Error
+	if err != nil {
+		fmt.Printf("CreateInBatches followDatas error:%v", err)
+		return
+	}
+
+	inviteDatas := getInviteFakeData(users)
+	err = db.CreateInBatches(inviteDatas, len(inviteDatas)).Error
+	if err != nil {
+		fmt.Printf("CreateInBatches inviteDatas error:%v", err)
+		return
+	}
+
+	joinDatas := getJoinFakeData(users)
+	err = db.CreateInBatches(joinDatas, len(joinDatas)).Error
+	if err != nil {
+		fmt.Printf("CreateInBatches joinDatas error:%v", err)
+		return
+	}
+
+	turntableDatas := getTurntableFakeData(users)
+	err = db.CreateInBatches(turntableDatas, len(turntableDatas)).Error
+	if err != nil {
+		fmt.Printf("CreateInBatches turntableDatas error:%v", err)
+		return
+	}
+
+	loginDatas := getLoginFakeData(users)
+	err = db.CreateInBatches(loginDatas, len(loginDatas)).Error
+	if err != nil {
+		fmt.Printf("CreateInBatches loginDatas error:%v", err)
+		return
+	}
+
+	rewardDatas := getRewardFakeData(users)
+	err = db.CreateInBatches(rewardDatas, len(rewardDatas)).Error
+	if err != nil {
+		fmt.Printf("CreateInBatches rewardDatas error:%v", err)
+		return
+	}
+
+	withdrawDatas := getWithdrawFakeData(users)
+	err = db.CreateInBatches(withdrawDatas, len(withdrawDatas)).Error
+	if err != nil {
+		fmt.Printf("CreateInBatches withdrawDatas error:%v", err)
+		return
+	}
+}
+
+func connectDb() *gorm.DB {
 	dsn := "clickhouse://default:123456@192.168.0.193:9000/default?dial_timeout=10s&read_timeout=20s"
 
 	newLogger := logger.New(
@@ -45,130 +153,59 @@ func main() {
 		panic("failed to connect database")
 	}
 
-	datas := make([]*eventmodels.AssetsEventContent, 0, 8)
-	count := 100
+	return db
+}
 
-	nameDatas := make([]*NameData, 0, 8)
-	for i := 0; i < 10; i++ {
-		user_id := faker.Name()
-		name := faker.Name()
-		tg_id := faker.Name()
-		x_id := faker.Name()
-		nameObj := &NameData{
-			User_id:   user_id,
-			User_name: name,
-			Tg_id:     tg_id,
-			X_id:      x_id,
-		}
-		nameDatas = append(nameDatas, nameObj)
-	}
-
-	server_id := "m-web-admin-1"
-	for i := 0; i < count; i++ {
-		index := rand.Intn(len(nameDatas))
-		user_id := nameDatas[index].User_id
-		user_name := nameDatas[index].User_name
-		tg_id := nameDatas[index].Tg_id
-		x_id := nameDatas[index].X_id
-		parent_user_id := nameDatas[index].User_name
-		is_robot := false
-		points_rank_seq := faker.RandomUnixTime()
-		throw_dice_rank_seq := faker.RandomUnixTime()
-		invite_user_rank_seq := faker.RandomUnixTime()
-		is_success := func() bool {
-			return rand.Intn(2) == 1
-		}
-		create_at := faker.RandomUnixTime()
-		operation_type := func() string {
-			if rand.Intn(2) == 1 {
-				return "increase"
-			}
-			return "decrease"
-		}
-		currency := func() string {
-			index := rand.Intn(3)
-			if index == 1 {
-				return "POINTS"
-			}
-			if index == 2 {
-				return "TON"
-			}
-			return "USDT"
-		}
-		reason := func() string {
-			if rand.Intn(2) == 1 {
-				return "reason"
-			}
-			return ""
-		}
-		var before_balance int64
-		var amount int64
-		var after_balance int64
-		before_balance = rand.Int63n(100000)
-		amount = rand.Int63n(1000)
-		after_balance = before_balance + amount
-
-		// email := faker.Email()
-		// address := faker.Address()
-		// phone := faker.Phone()
-
-		datas = append(datas, &eventmodels.AssetsEventContent{
-			UserBasic: eventmodels.UserBasic{
-				UserId:            user_id,
-				UserName:          user_name,
-				TgId:              tg_id,
-				XId:               x_id,
-				ParentUserId:      parent_user_id,
-				IsRobot:           is_robot,
-				PointsRankSeq:     points_rank_seq,
-				ThrowDiceRankSeq:  throw_dice_rank_seq,
-				InviteUserRankSeq: invite_user_rank_seq,
-			},
-			EventBasic: eventmodels.EventBasic{
-				ServerId:  server_id,
-				IsSuccess: is_success(),
-				CreateAt:  create_at,
-			},
-			OperationType: operation_type(),
-			Currency:      currency(),
-			Reason:        reason(),
-			BeforeBalance: before_balance,
-			Amount:        amount,
-			AfterBalance:  after_balance,
-		})
-	}
-
-	err = db.CreateInBatches(datas, len(datas)).Error
-	if err != nil {
-		fmt.Printf("CreateInBatches error:%v", err)
-		return
+func getUserBasic(users []*eventmodels.UserBasic) *eventmodels.UserBasic {
+retry:
+	index := rand.Intn(len(users))
+	user := users[index]
+
+	if user.UserStatus != 1 {
+		goto retry
 	}
 
-	// sqlStr := `select SUM(amount) as total_amount from assets_event_contents where user_id = ? and currency = ?`
-	var total_amount int64
-	for _, nameObj := range nameDatas {
-		// err := db.Raw(sqlStr, name, "USDT").Pluck("SUM(amount) as total_amount", &total_amount).Error
-		// if err != nil {
-		// 	fmt.Printf("Pluck error:%v", err)
-		// 	return
-		// }
-
-		where := &eventmodels.AssetsEventContent{
-			UserBasic: eventmodels.UserBasic{
-				UserId: nameObj.User_id,
-				// UserId: "1", // 不存在的用户
-			},
-			EventBasic: eventmodels.EventBasic{
-				ServerId: server_id,
-			},
-			Currency: "USDT",
-		}
-		err := db.Model(&eventmodels.AssetsEventContent{}).Where(where).Pluck("SUM(amount) as total_amount", &total_amount).Error
-		if err != nil {
-			fmt.Printf("Pluck error:%v", err)
-			return
-		}
+	return &eventmodels.UserBasic{
+		UserId:            user.UserId,
+		UserName:          user.UserName,
+		TgId:              user.TgId,
+		XId:               user.XId,
+		ParentUserId:      user.ParentUserId,
+		IsRobot:           user.IsRobot,
+		IfTgVip:           user.IfTgVip,
+		TonWall:           user.TonWall,
+		Email:             user.Email,
+		Fingerprint:       user.Fingerprint,
+		Level:             user.Level,
+		UserStatus:        user.UserStatus,
+		PointsRankSeq:     user.PointsRankSeq,
+		ThrowDiceRankSeq:  user.ThrowDiceRankSeq,
+		InviteUserRankSeq: user.InviteUserRankSeq,
+	}
+}
 
-		fmt.Printf("User_id:%s total_amount:%v", nameObj.User_id, total_amount)
+func getEventBasic() *eventmodels.EventBasic {
+	return &eventmodels.EventBasic{
+		ServerId:         server_id,
+		IsSuccess:        rand.Intn(2) == 1,
+		Status:           rand.Intn(2),
+		RewardDrawStatus: rand.Intn(2),
+		CreateAt:         faker.RandomUnixTime(),
 	}
 }
+
+func getPlatform() string {
+	datas := make([]string, 0, 8)
+	datas = append(datas, "pc", "h5", "ios", "android")
+
+	index := rand.Intn(len(datas))
+	return datas[index]
+}
+
+func getChannel() string {
+	datas := make([]string, 0, 8)
+	datas = append(datas, "tg")
+
+	index := rand.Intn(len(datas))
+	return datas[index]
+}

game/game_cluster/nodes/logstash/fakedata/register.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+	"github.com/bxcodec/faker/v3"
+	"github.com/mhaya/game/game_cluster/internal/mdb/eventmodels"
+)
+
+func getregisterFakeData(users []*eventmodels.UserBasic) []*eventmodels.UserRegisterEventContent {
+	datas := make([]*eventmodels.UserRegisterEventContent, 0, 8)
+
+	for _, user := range users {
+		eventBasic := getEventBasic()
+
+		datas = append(datas, &eventmodels.UserRegisterEventContent{
+			UserBasic:  *user,
+			EventBasic: *eventBasic,
+			Ip:         faker.IPv4(),
+			Platform:   getPlatform(),
+			Channel:    getChannel(),
+			Source:     "",
+		})
+	}
+
+	return datas
+}

game/game_cluster/nodes/logstash/fakedata/reward.go

@@ -0,0 +1,62 @@
+package main
+
+import (
+	"math/rand"
+
+	jsoniter "github.com/json-iterator/go"
+	"github.com/mhaya/game/game_cluster/internal/mdb/eventmodels"
+)
+
+var (
+	json = jsoniter.ConfigCompatibleWithStandardLibrary
+)
+
+func getRewardFakeData(users []*eventmodels.UserBasic) []*eventmodels.UserRewardEventContent {
+	datas := make([]*eventmodels.UserRewardEventContent, 0, 8)
+
+	source := rand.Intn(12) + 1
+
+	addRewards := make([]eventmodels.ItemReward, 0, 8)
+	addRewards = append(addRewards, eventmodels.ItemReward{
+		ItemBaseType: rand.Intn(5) + 1,
+		ItemID:       rand.Intn(10) + 1,
+		Amount:       rand.Intn(100) + 1,
+	})
+
+	desc := ""
+	switch source {
+	case 11: // SourceDraw
+		descDraw := eventmodels.DescDraw{
+			ID:     rand.Intn(12) + 1,
+			CurID:  rand.Intn(12) + 1,
+			Reward: addRewards,
+		}
+
+		bytes, err := json.Marshal(descDraw)
+		if err != nil {
+			panic(err)
+		}
+
+		desc = string(bytes)
+
+	default:
+		desc = ""
+	}
+
+	for i := 0; i < count; i++ {
+		userBasic := getUserBasic(users)
+		eventBasic := getEventBasic()
+
+		datas = append(datas, &eventmodels.UserRewardEventContent{
+			UserBasic:  *userBasic,
+			EventBasic: *eventBasic,
+			Source:     source,
+			SourceId:   rand.Intn(2) + 1,
+			AddReward:  "",
+			SubReward:  "",
+			Desc:       desc,
+		})
+	}
+
+	return datas
+}

game/game_cluster/nodes/logstash/fakedata/turntable.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"math/rand"
+
+	"github.com/bxcodec/faker/v3"
+	"github.com/mhaya/game/game_cluster/internal/mdb/eventmodels"
+)
+
+func getTurntableFakeData(users []*eventmodels.UserBasic) []*eventmodels.TurntableEventContent {
+	datas := make([]*eventmodels.TurntableEventContent, 0, 8)
+
+	for i := 0; i < count; i++ {
+		userBasic := getUserBasic(users)
+		eventBasic := getEventBasic()
+
+		datas = append(datas, &eventmodels.TurntableEventContent{
+			UserBasic:   *userBasic,
+			EventBasic:  *eventBasic,
+			PrizeName:   faker.Name(),
+			PrizeNumber: rand.Int63n(50) + 1,
+		})
+	}
+
+	return datas
+}

game/game_cluster/nodes/logstash/fakedata/updateUserInfo.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"math/rand"
+
+	"github.com/bxcodec/faker/v3"
+	"github.com/mhaya/game/game_cluster/internal/mdb/eventmodels"
+)
+
+func getUpdateInfoFakeData(users []*eventmodels.UserBasic) []*eventmodels.UserUpdateInfoEventContent {
+	datas := make([]*eventmodels.UserUpdateInfoEventContent, 0, 8)
+
+	for _, user := range users {
+		eventBasic := getEventBasic()
+
+		content := &eventmodels.UserUpdateInfoEventContent{
+			EventBasic: *eventBasic,
+			// UpdateUserName:    "",
+			// UpdateTgId:        "",
+			// UpdateXId:         "",
+			// UpdateTonWall:     "",
+			// UpdateFingerprint: "",
+			// UpdateEmail:       "",
+			// UpdateMobile:      "",
+			// UpdateAvatar:      "",
+			// UpdateBirthday:    "",
+			// UpdatePassword:    "",
+			// UpdateSalt:        "",
+			// UpdateIsLeader:    false,
+			// UpdateIsVip:       false,
+			// UpdateLevel:       0,
+			// UpdateExp:         0,
+			// UpdateGender:      0,
+		}
+
+		hasUpdate := false
+		if rand.Intn(5) == 1 {
+			data := faker.Name()
+			user.UserName = data
+			content.UpdateUserName = data
+
+			hasUpdate = true
+		}
+
+		if rand.Intn(3) == 1 {
+			data := faker.Email()
+			user.Email = data
+			content.UpdateEmail = data
+
+			hasUpdate = true
+		}
+
+		if rand.Intn(2) == 1 {
+			data := faker.Phonenumber()
+			content.UpdateMobile = data
+
+			hasUpdate = true
+		}
+
+		content.UserBasic = *user
+
+		if hasUpdate {
+			datas = append(datas, content)
+		}
+	}
+
+	return datas
+}

game/game_cluster/nodes/logstash/fakedata/withdraw.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+	"math/rand"
+
+	"github.com/bxcodec/faker/v3"
+	"github.com/mhaya/game/game_cluster/internal/constant"
+	"github.com/mhaya/game/game_cluster/internal/mdb/eventmodels"
+)
+
+func getWithdrawEventBasic() *eventmodels.EventBasic {
+	return &eventmodels.EventBasic{
+		ServerId:         server_id,
+		IsSuccess:        rand.Intn(2) == 1,
+		Status:           rand.Intn(5),
+		RewardDrawStatus: rand.Intn(2),
+		CreateAt:         faker.RandomUnixTime(),
+	}
+}
+
+func getWithdrawFakeData(users []*eventmodels.UserBasic) []*eventmodels.UserWithdrawEventContent {
+	datas := make([]*eventmodels.UserWithdrawEventContent, 0, 8)
+
+	for i := 0; i < count; i++ {
+		userBasic := getUserBasic(users)
+		eventBasic := getWithdrawEventBasic()
+
+		var before int64
+		before = 10000
+		amount := rand.Int63n(1000) + 1
+
+		datas = append(datas, &eventmodels.UserWithdrawEventContent{
+			UserBasic:  *userBasic,
+			EventBasic: *eventBasic,
+			WithdrawId: faker.TimeString(),
+			Currency: func() string {
+				if rand.Intn(2) == 1 {
+					return string(constant.UsdtCurrency)
+				}
+
+				return string(constant.TonCurrency)
+			}(),
+			Ip:            faker.IPv4(),
+			Platform:      getPlatform(),
+			Channel:       getChannel(),
+			Address:       userBasic.TonWall,
+			BeforeBalance: before,
+			Amount:        amount,
+			AfterBalance:  before - amount,
+			Reason:        "",
+			State:         rand.Intn(2),
+		})
+	}
+
+	return datas
+}