tyj_admin/utils/util.go

package utils

import (
	"bytes"
	"context"
	"fmt"
	"github.com/gogf/gf/v2/frame/g"
	"log"
	"math/rand"
	"os"
	"os/exec"
	"strconv"
	"strings"
	"time"
	"tyj_admin/internal/model/entity"
)

// int
func RandInt(min int, max int) int {
	return min + rand.Intn(max-min)
}

// int
func RandInt32(min int32, max int32) int32 {
	return min + rand.Int31n(max-min)
}

// float
func RandomFloat(min, max int) float64 {
	if max == min {
		return float64(max)
	}
	return decimal(rand.Float64()*(float64(max)-float64(min)) + float64(min))
}

func decimal(v float64) float64 {
	val, _ := strconv.ParseFloat(fmt.Sprintf("%.3f", v), 64)
	return val
}
func RandomByWeight(weights []int32) int32 {
	if len(weights) == 0 {
		return -1
	}
	if len(weights) == 1 {
		return 0
	}

	var sum int32 = 0
	for _, v := range weights {
		sum += v
	}

	numberRand := rand.Int31n(sum)
	var sumTemp int32 = 0
	for k, v := range weights {
		sumTemp += v
		if numberRand <= sumTemp {
			return int32(k)
		}
	}

	return -1
}
func RandomByWeightInt(weights []int32) int {
	if len(weights) == 0 {
		return -1
	}
	if len(weights) == 1 {
		return 0
	}

	var sum int32 = 0
	for _, v := range weights {
		sum += v
	}

	numberRand := rand.Int31n(sum)
	var sumTemp int32 = 0
	for k, v := range weights {
		sumTemp += v
		if numberRand <= sumTemp {
			return k
		}
	}

	return -1
}

func ContainsGeneric(slice []interface{}, element interface{}) bool {
	for _, e := range slice {
		if e == element {
			return true
		}
	}

	return false
}

func ContainsString(slice []string, element string) bool {
	for _, e := range slice {
		if e == element {
			return true
		}
	}

	return false
}

func DeleteSlice1(a []string, elem string) []string {
	for i := 0; i < len(a); i++ {
		if a[i] == elem {
			a = append(a[:i], a[i+1:]...)
			i--
		}
	}
	return a
}

func TopIpWhiteList(ip string) bool {
	ipList := [1]string{"192.168.2.115"}
	for _, v := range ipList {
		if v == ip {
			return true
		}
	}

	return false
}

func ContainsWhiteList(slice []*entity.GameWhiteList, element string) bool {
	for _, e := range slice {
		if e.Ip == element {
			return true
		}
	}

	return false
}

func ContainsBlackList(slice []*entity.GameBlackList, element string) bool {
	for _, e := range slice {
		if e.Ip == element {
			return true
		}
	}

	return false
}

func Check(e error) {
	if e != nil {
		panic(e)
	}
}

/**
 * 判断文件是否存在  存在返回 true 不存在返回false
 */
func CheckFileIsExist(filename string) bool {
	var exist = true
	if _, err := os.Stat(filename); os.IsNotExist(err) {
		exist = false
	}
	return exist
}

func CmdCommand(ctx context.Context, name string, args ...string) (err error) {
	err = g.Try(ctx, func(ctx context.Context) {
		cmd := exec.Command(name, args...)
		var stdout, stderr bytes.Buffer
		cmd.Stdout = &stdout // 标准输出
		cmd.Stderr = &stderr // 标准错误
		err = cmd.Run()
		if err != nil {
			log.Printf("cmd.Run() failed with %s\n", err)
			return
		}
		outStr, errStr := string(stdout.Bytes()), string(stderr.Bytes())
		fmt.Printf("out:\n%s\nerr:\n%s\n", outStr, errStr)
	})
	return
}

const charset = "0123456789"

var seededRand *rand.Rand = rand.New(rand.NewSource(time.Now().UnixNano()))

func GenerateRandomString(length int) string {
	b := make([]byte, length)
	for i := range b {
		b[i] = charset[seededRand.Intn(len(charset))]
	}
	return string(b)
}

func GetAccount(account, channel string) string {
	if channel == "000000000000" && !strings.Contains(account, channel) {
		account = channel + account
	}
	return account
}