baseapi/utils/utils.go

package utils

import (
	"encoding/base64"
	"fmt"
	"net/http"
	"net/url"
	"reflect"
	"strings"
	"time"
	"unicode/utf8"

	"git.rosy.net.cn/baseapi"
	uuid "github.com/satori/go.uuid"
)

func DictKeysMan(data interface{}, keysToRemove []string, keysToKeep []string) interface{} {
	if data == nil || (keysToKeep == nil && keysToRemove == nil) {
		return data
	}

	var keysToRemoveMap map[string]int
	var keysToKeepMap map[string]int
	if keysToKeep != nil {
		keysToKeepMap = make(map[string]int)
		for _, v := range keysToKeep {
			keysToKeepMap[v] = 1
		}
	} else if keysToRemove != nil {
		keysToRemoveMap = make(map[string]int)
		for _, v := range keysToRemove {
			keysToRemoveMap[v] = 1
		}
	}

	dataIsSlice := true
	valueOfData := reflect.ValueOf(data)
	if valueOfData.Kind() != reflect.Slice {
		dataIsSlice = false
		valueOfData = reflect.ValueOf([]interface{}{data})
	} else if valueOfData.Len() == 0 {
		return data
	}

	retVal := make([]interface{}, valueOfData.Len())

	for index := 0; index < valueOfData.Len(); index++ {
		realV := GetConcretValue(valueOfData.Index(index))
		if keysToRemoveMap != nil || keysToKeepMap != nil {
			mapV := make(map[string]interface{})
			for _, key := range realV.MapKeys() {
				fieldName := key.String()
				wantThisField := true
				if keysToKeepMap != nil {
					if _, ok := keysToKeepMap[fieldName]; !ok {
						wantThisField = false
					}
				} else if keysToRemoveMap != nil {
					if _, ok := keysToRemoveMap[fieldName]; ok {
						wantThisField = false
					}
				}
				if wantThisField {
					mapV[fieldName] = GetConcretValue(realV.MapIndex(key)).Interface()
				}
			}
			retVal[index] = mapV
		} else {
			retVal[index] = realV.Interface()
		}
	}

	if !dataIsSlice {
		return retVal[0]
	}
	return retVal
}

// 去除-号，全部大写，比如：929ADB626EB911E893E452540009DAB3
func GetUUID() string {
	return strings.Replace(GetUpperUUID(), "-", "", -1)
}

func GetUpperUUID() string {
	return strings.ToUpper(uuid.Must(uuid.NewV1()).String())
}

func GetCurTimeStr() string {
	return Time2Str(time.Now())
}

func GetCurDate() time.Time {
	now := time.Now()
	year, month, day := now.Date()
	return time.Date(year, month, day, 0, 0, 0, 0, now.Location())
}

// timestamp is in second
func GetCurTimestamp() int64 {
	return time.Now().Unix()
}

func GetAPIOperator(userName string) string {
	retVal := "jxc4-admin"
	if userName != "" {
		retVal += "-" + userName
	}
	return retVal
}

func MergeMaps(firstMap map[string]interface{}, otherMaps ...map[string]interface{}) (retVal map[string]interface{}) {
	retVal = make(map[string]interface{})
	allMaps := append(otherMaps, firstMap)
	for _, oneMap := range allMaps {
		for k, v := range oneMap {
			retVal[k] = v
		}
	}

	return retVal
}

func CallFuncLogError(funcToCall func() error, msg string, params ...interface{}) error {
	err := funcToCall()
	if err != nil {
		baseapi.SugarLogger.Warnf("Failed "+msg+" error:%v", append(params, err.Error())...)
	}
	return err
}

func CallFuncLogErrorIgnore(funcToCall func() error, msg string, ignoreErr error, params ...interface{}) error {
	err := funcToCall()
	if err != nil && err != ignoreErr {
		baseapi.SugarLogger.Warnf("Failed "+msg+" error:%v", append(params, err.Error())...)
	}
	return err
}

func CallFuncLogErrorWithInfo(funcToCall func() error, msg string, params ...interface{}) error {
	err := funcToCall()
	if err != nil {
		baseapi.SugarLogger.Infof("Failed "+msg+" error:%v", append(params, err.Error())...)
	}
	return err
}

func CallFuncAsync(funcToCall func()) {
	go func() {
		defer func() {
			if r := recover(); r != nil {
				baseapi.SugarLogger.Errorf("error when calling func:%v, r:%v", funcToCall, r)
			}
		}()
		funcToCall()
	}()
}

func AfterFuncWithRecover(duration time.Duration, funcToCall func()) *time.Timer {
	return time.AfterFunc(duration, func() {
		defer func() {
			if r := recover(); r != nil {
				baseapi.SugarLogger.Errorf("error when calling func:%v, r:%v", funcToCall, r)
			}
		}()
		funcToCall()
	})
}

func CallFuncRetryAsync(handler func(int) error, duration time.Duration, retryCount int) (err error) {
	err = handler(retryCount)
	if err != nil && retryCount > 0 {
		AfterFuncWithRecover(duration, func() {
			CallFuncRetryAsync(handler, duration, retryCount-1)
		})
	}
	return err
}

func GenerateGetURL(baseURL, apiStr string, params map[string]interface{}) string {
	queryString := ""
	if params != nil {
		for k, v := range params {
			if queryString == "" {
				queryString = "?"
			} else {
				queryString += "&"
			}
			queryString += k + "=" + url.QueryEscape(fmt.Sprint(v))
		}
	}
	if apiStr != "" {
		return baseURL + "/" + apiStr + queryString
	}
	return baseURL + queryString
}

func SendFakeRequest(method, url, body, contentType string) (*http.Response, error) {
	request, _ := http.NewRequest(method, url, strings.NewReader(body))
	if contentType == "" {
		contentType = "application/x-www-form-urlencoded"
	}
	request.Header.Set("Content-Type", contentType)
	client := &http.Client{}
	return client.Do(request)
}

// 过滤 utf8mb4（比如emoji表情）
func FilterMb4(content string) string {
	newContent := &strings.Builder{}
	for _, value := range content {
		size := utf8.RuneLen(value)
		if size >= 1 && size <= 3 {
			newContent.WriteRune(value)
		}
	}
	return newContent.String()
}

func TrimBlankChar(str string) string {
	return strings.Trim(str, "\n\r\t ")
}

func RemoveGeneralMapKeys(obj map[string]interface{}, keys ...string) map[string]interface{} {
	if obj != nil {
		for _, key := range keys {
			if _, ok := obj[key]; ok {
				delete(obj, key)
			}
		}
	}
	return obj
}

func FilterMapNilMembers(mapData map[string]interface{}) map[string]interface{} {
	for k, v := range mapData {
		if v == nil {
			delete(mapData, k)
		}
	}
	return mapData
}

func Base64DecodeMultiString(strs ...string) (decodedData [][]byte, err error) {
	decodedData = make([][]byte, len(strs))
	for k, v := range strs {
		if decodedData[k], err = base64.StdEncoding.DecodeString(v); err != nil {
			return nil, err
		}
	}
	return decodedData, nil
}

func LimitStringLen(str string, maxLen int) (limitedStr string) {
	if maxLen > 0 {
		if strLen := len(str); strLen > maxLen {
			str = str[:maxLen]
		}
	}
	return str
}

func LimitUTF8StringLen(str string, maxLen int) (limitedStr string) {
	if maxLen > 0 {
		if len(str) > maxLen {
			runeList := []rune(str)
			if len(runeList) > maxLen {
				str = string(runeList[:maxLen])
			}
		}
	}
	return str
}