ifms_go/pkg/util/helper.go

package util

import (
	"bytes"
	"crypto/md5"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"math"
	"os/exec"
	"regexp"
	"strconv"
	"strings"
	"syscall"
	"time"
)

func MySplit(data string, separatorChar string) []string {
	items := strings.Split(data, separatorChar)

	var result []string
	for _, item := range items {
		if len(item) > 0 {
			result = append(result, item)
		}
	}
	return result
}

func IsBase64(str string) bool {
	pattern := "^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$"
	matched, err := regexp.MatchString(pattern, str)
	if err != nil {
		return false
	}
	if !(len(str)%4 == 0 && matched) {
		return false
	}
	unCodeStr, err := base64.StdEncoding.DecodeString(str)
	if err != nil {
		return false
	}
	tranStr := base64.StdEncoding.EncodeToString(unCodeStr)
	//return str==base64.StdEncoding.EncodeToString(unCodeStr)
	if str == tranStr {
		return true
	}
	return false
}

func IsNum(s string) bool {
	_, err := strconv.ParseFloat(s, 64)
	return err == nil
}

func Md5(source string) string {

	h := md5.New()
	h.Write([]byte(source)) // 需要加密的字符串
	cipherStr := h.Sum(nil)
	return hex.EncodeToString(cipherStr) // 输出加密结果

}

// 将字符串转为int64
func Str2Int64(str string, def int64) int64 {
	if str == "" {
		return def
	}
	i, err := strconv.ParseInt(str, 10, 64)
	if err != nil {
		return def
	}
	return i
}

func Str2Int(str string, def int) int {
	if str == "" {
		return def
	}

	i, err := strconv.Atoi(str)

	if err != nil {
		return def
	}
	return i
}
func Int2Float(in int, def float64) float64 {

	i, err := strconv.ParseFloat(strconv.Itoa(in), 64)

	if err != nil {
		return def
	}
	return i
}

// 四舍五入，保留2位
func Str2Money(str string, def float64) float64 {
	if str == "" {
		return def
	}
	i, err := strconv.ParseFloat(str, 64)
	if err != nil {
		return def
	}
	i = Round(i, 2)
	return i
}

func Round(f float64, n int) float64 {
	n10 := math.Pow10(n)
	return math.Trunc((f+0.5/n10)*n10) / n10
}

// 保留x位小数
func Float2Str(f float64, fix int) string {
	return fmt.Sprintf("%0."+strconv.Itoa(fix)+"f", f)
}

// 将int转为string
func Int2String(i int) string {

	return strconv.Itoa(i)
}

func Int642String(i int64) string {

	return strconv.FormatInt(i, 10)
}

// 将对象以json形式打印出来，此方法主要用开发调试
func PrintObject4Json(obj interface{}) {
	res1B, _ := json.Marshal(obj)
	fmt.Println(string(res1B))
}

// 获取当前时间，并格式化为 yyyy-MM-dd HH:MM:SS
func GetCurrentLongDate() string {
	return time.Now().Format("2006-01-02 15:04:05")
}
func GetCurrentMaxLongDate() string {
	return time.Now().Format("2006-01-02") + " 23:59:59"
}

func GetTheDateMaxLongDate(date time.Time) string {
	return date.Format("2006-01-02") + " 23:59:59"
}
func GetTheDateMinLongDate(date time.Time) string {
	return date.Format("2006-01-02") + " 00:00:00"
}

func GetCurrentUnixDTInt64() int64 {
	return time.Now().Unix()
}

// 获取当前时间（秒）
func GetCurrentUnixDTString() string {
	return Int642String(GetCurrentUnixDTInt64())
}

// 获取当前时间（毫秒）
func GetCurrentUnixDTMicroSecondString() string {
	return Int642String(GetCurrentUnixDTInt64() * 1000)
}

// 获取以当前时间为基准的以前或是今后，days为负，表示以前，为正表示今后
func GetDateBeforeOrAfter(days int) string {
	return time.Now().AddDate(0, 0, days).Format("2006-01-02 15:04:05")
}

func GetDateTimeBeforeOrAfter(days int) time.Time {
	return time.Now().AddDate(0, 0, days)
}

func GetDateTimeBeforeOrAfterBaseCurrent(date time.Time, minute int) time.Time {
	return date.Add(time.Minute * time.Duration(minute))
}

// 获取以当前时间为基准的前X分钟或后X分钟， minute 为负，表示以前，为正表示今后
func GetDateBeforeOrAfterMinute(minute int) string {
	return time.Now().Add(time.Minute * time.Duration(minute)).Format("2006-01-02 15:04:05")
}

// 获取以当前时间为基准的前X分钟或后X分钟， minute 为负，表示以前，为正表示今后
func GetDateTimeBeforeOrAfterMinute(minute int) time.Time {
	return time.Now().Add(time.Minute * time.Duration(minute))
}

func ConvertLongDate(tm time.Time) string {
	return tm.Format("2006-01-02 15:04:05")
}
func ConvertShortDate(tm time.Time) string {

	return tm.Format("2006-01-02")
}

// 将对象转为json
func Object4Json(obj interface{}) string {
	res1B, err := json.Marshal(obj)
	if err != nil {
		return ""
	}
	return string(res1B)
}

/*
*

	压json
*/
func JsonEncode(ob interface{}) []byte {
	if b, err := json.Marshal(ob); err == nil {
		return b
	}
	return []byte("")
}

/*
*

	解json
*/
func JsonDecode(data []byte, ob interface{}) error {
	return json.Unmarshal(data, ob)
}

func JsonString2Struct(jsondata string, ob interface{}) error {
	return json.Unmarshal([]byte(jsondata), ob)
}

/*
*
将json字符串转成map
*/
func JsonString2Map(jsonData string) (error, map[string]interface{}) {
	result := make(map[string]interface{})
	err := json.Unmarshal([]byte(jsonData), &result)
	return err, result
}
func Json2StrMap(jsonData string) (map[string]string, error) {
	result := make(map[string]string)
	err := json.Unmarshal([]byte(jsonData), &result)
	return result, err
}

// 将对象以json形式打印出来，此方法主要用开发调试
func Object4FeeLog(obj interface{}) string {
	res1B, err := json.Marshal(obj)
	if err != nil {
		return ""
	}
	strlog := string(res1B)
	if len(strlog) > 4500 {
		return strlog[1 : len(strlog)-4500]
	}
	return strlog
}

// 将对象以json形式打印出来，此方法主要用开发调试
func Object2String(obj interface{}, def string) string {

	if obj == nil {
		return def
	}
	strlog := obj.(string)
	return strlog
}

/*
*
获取固定时间2000-01-01 00:00:00,因为mysql不允许存入0000-00-00这样的格式
*/
func GetFixMinDate() time.Time {
	local, _ := time.LoadLocation("Asia/Shanghai")
	t, _ := time.ParseInLocation("2006-01-02 15:04:05", "2000-01-01 00:00:00", local)
	return t
}
func GetFixMinStringDate() string {
	return "2000-01-01 00:00:00"
}

func ConvertStr2DateTime(strdt string) (time.Time, error) {
	local, _ := time.LoadLocation("Asia/Shanghai")
	if len(strdt) > 10 {
		return time.ParseInLocation("2006-01-02 15:04:05", strdt, local)
	}
	return time.ParseInLocation("2006-01-02", strdt, local)
}

//func ConvertStr2ShortDateTime(strdt string) (time.Time, error) {
//	local, _ := time.LoadLocation("Asia/Shanghai")
//	return time.ParseInLocation("2006-01-02", strdt, local)
//}

// 计算2个日期相差多少小时,end-start
func DateTimeDiffHours(start string, end string) (float64, error) {
	dtstart, err := time.Parse("2006-01-02 15:04:05", start)
	if err != nil {
		return 0, errors.New("开始时间无效，格式：yyyy-MM-dd HH:mm:ss")
	}
	dtend, err := time.Parse("2006-01-02 15:04:05", end)
	if err != nil {
		return 0, errors.New("结束时间无效，格式：yyyy-MM-dd HH:mm:ss")
	}

	time_hour := dtend.Sub(dtstart).Hours()
	return time_hour, nil

}

// 计算2个日期相差多少分钟
func DateTimeDiffMinutes(start string, end string) (float64, error) {
	dtstart, err := time.Parse("2006-01-02 15:04:05", start)
	if err != nil {
		return 0, errors.New("开始时间无效，格式：yyyy-MM-dd HH:mm:ss")
	}
	dtend, err := time.Parse("2006-01-02 15:04:05", end)
	if err != nil {
		return 0, errors.New("结束时间无效，格式：yyyy-MM-dd HH:mm:ss")
	}

	time_hour := dtend.Sub(dtstart).Minutes()
	return time_hour, nil

}

func ExecCommand(timeout time.Duration, name string, args ...string) (result []byte, err error) {

	cmd := exec.Command(name, args...)

	cmd.SysProcAttr = &syscall.SysProcAttr{
		// Setpgid: true,
		// Pgid:    0,
	}

	stdin, err := cmd.StdinPipe()
	if err != nil {
		return
	}

	stdout, err := cmd.StdoutPipe()
	if err != nil {
		return
	}

	stderr, err := cmd.StderrPipe()
	if err != nil {
		return
	}

	outBuf := bytes.NewBuffer(nil)
	errBuf := bytes.NewBuffer(nil)

	if err != nil {
		return
	}

	err = cmd.Start()

	if err != nil {
		return
	}

	//if len(data) > 0 {
	//	_, err = io.Copy(stdin, bytes.NewBuffer(data))
	//	if err != nil {
	//		return
	//	}
	//}

	stdin.Close()

	go io.Copy(outBuf, stdout)
	go io.Copy(errBuf, stderr)

	ch := make(chan error)

	go func(cmd *exec.Cmd) {
		defer close(ch)
		ch <- cmd.Wait()
	}(cmd)

	select {
	case err = <-ch:
	case <-time.After(timeout):
		cmd.Process.Kill()
		err = errors.New("execute timeout")
		return
	}

	if err != nil {
		errStr := errBuf.String()
		return nil, errors.New(errStr)
	}

	if outBuf.Len() > 0 {
		return outBuf.Bytes(), nil
	}

	return
}

func NewError(msg string) error {
	return errors.New(msg)
}

// 由于号码段变化太大，直接用11位数字
func VerifyMobileFormat(mobileNum string) bool {
	regular := "^\\d{11}$"
	reg := regexp.MustCompile(regular)
	return reg.MatchString(mobileNum)
}

/*
*
提取主账号
*/
func PickMainUserNick(sellerNick string) string {
	subIndex := strings.Index(sellerNick, ":")
	if subIndex > -1 {
		mainSellerNick := sellerNick[0:subIndex]
		return mainSellerNick
	}
	return sellerNick
}