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

package main

import (
	"fmt"
	"log"
	"math/rand"
	"os"
	"time"

	"github.com/bxcodec/faker/v3"
	"github.com/mhaya/game/game_cluster/internal/mdb/eventmodels"
	"gorm.io/driver/clickhouse"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
)

// `insert into assets_event_contents (user_id, user_name, tg_id, x_id, parent_user_id, is_robot, points_rank_seq,
//                                    throw_dice_rank_seq, invite_user_rank_seq, is_success, create_at, operation_type,
//                                    currency, reason, before_balance, amount, after_balance, server_id)
// values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`

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(
		log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer（日志输出的地方，这里是标准输出）
		logger.Config{
			SlowThreshold: time.Second, // 慢 SQL 阈值
			LogLevel:      logger.Info, // 日志级别
			Colorful:      true,        // 彩色打印
		},
	)

	db, err := gorm.Open(clickhouse.Open(dsn), &gorm.Config{
		Logger: newLogger,
	})
	if err != nil {
		panic("failed to connect database")
	}

	return db
}

func getUserBasic(users []*eventmodels.UserBasic) *eventmodels.UserBasic {
retry:
	index := rand.Intn(len(users))
	user := users[index]

	if user.UserStatus != 1 {
		goto retry
	}

	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,
	}
}

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]
}