electricity_bill_calc_service/tools/utils.go

package tools

import (
	"database/sql"
	"encoding/json"
	"fmt"
	"strings"
	"time"

	"github.com/mozillazg/go-pinyin"
	"github.com/samber/lo"
	"github.com/shopspring/decimal"
)

func ContainsInsensitive(element string, slice []string) bool {
	lowercasedElement := strings.TrimSpace(strings.ToLower(element))
	return lo.Contains(slice, lowercasedElement)
}

func PinyinAbbr(source string) string {
	abbr := pinyin.Pinyin(source, pinyin.NewArgs())
	var abbrCollect = make([]string, 0)
	for _, a := range abbr {
		abbrCollect = append(abbrCollect, a[0][0:1])
	}
	finalAbbr := strings.Join(abbrCollect, "")
	return finalAbbr
}

// 将给定结构体的内容通过JSON转换为`map[string]interface{}`类型的值
func ConvertStructToMap[T any](origin T) map[string]interface{} {
	incr, _ := json.Marshal(origin)
	var dest map[string]interface{}
	json.Unmarshal(incr, &dest)
	return dest
}

func ConvertSliceToInterfaceSlice[T any](origin []T) []interface{} {
	dest := make([]interface{}, len(origin))
	for i, e := range origin {
		dest[i] = e
	}
	return dest
}

// 对指定的数组进行分区
func PartitionSlice[T any](slice []T, chunkSize int) [][]T {
	var divided [][]T
	for i := 0; i < len(slice); i += int(chunkSize) {
		end := i + chunkSize
		if end > len(slice) {
			end = len(slice)
		}
		divided = append(divided, slice[i:end])
	}
	return divided
}

// 判断指定指针是否为空，如果为空，则返回指定默认值（指针形式）
func DefaultTo[T any](originValue *T, defaultValue T) T {
	if originValue == nil {
		return defaultValue
	}
	return *originValue
}

// 判断指定的指针是否为空，如果为空，则返回指定的默认字符串，或者返回指针所指内容的字符串形式。
func DefaultStrTo[T any](format string, originValue *T, defaultStr string) string {
	if originValue == nil {
		return defaultStr
	}
	return fmt.Sprintf(format, originValue)
}

// 判断指定字符串指针是否为`nil`或者字符串长度为空，如果是则返回给定的默认字符串，否则返回指针所指内容的字符串形式。
func DefaultOrEmptyStr(originValue *string, defaultStr string) string {
	if originValue == nil || len(*originValue) == 0 {
		return defaultStr
	}
	return *originValue
}

// 判断指定表达式的值，根据表达式的值返回指定的值。相当于其他语言中的三目运算符。
func Cond[T any](expr bool, trueValue, falseValue T) T {
	if expr {
		return trueValue
	}
	return falseValue
}

// 使用给定的函数对指定的值进行判断，根据表达式的值返回指定的值。
func CondFn[T, R any](exprFn func(val T) bool, value T, trueValue, falseValue R) R {
	return Cond(exprFn(value), trueValue, falseValue)
}

// 使用给定的函数对指定的值进行判断，根据表达式的值返回指定的值。本函数为惰性求值。
func CondFnElse[T, R any](exprFn func(val T) bool, value T, trueValueFn func(val T) R, falseValueFn func(val T) R) R {
	if exprFn(value) {
		return trueValueFn(value)
	}
	return falseValueFn(value)
}

// 使用给定的函数对指定的值进行判断，如果表达式为真，则返回指定的值，否则返回另一个值。
func CondOr[T any](exprFn func(val T) bool, value, elseValue T) T {
	return CondFn(exprFn, value, value, elseValue)
}

// 将指定的字符串指针解析为一个可空的`decimal.NullDecimal`类型的值。
func NewNullDecimalFromString(val *string) (decimal.NullDecimal, error) {
	if val == nil {
		return decimal.NullDecimal{Valid: false}, nil
	}
	nd, err := decimal.NewFromString(*val)
	if err != nil {
		return decimal.NullDecimal{Valid: false}, err
	}
	return decimal.NullDecimal{Decimal: nd, Valid: true}, nil
}

// 将指定的字符串指针解析为一个`decimal.Decimal`类型的值，必须提供一个默认值，以用来替换解析失败以及空指针的情况。
func NewDecimalFromString(val *string, defaultValue decimal.Decimal) decimal.Decimal {
	if val == nil {
		return defaultValue
	}
	nd, err := decimal.NewFromString(*val)
	if err != nil {
		return defaultValue
	}
	return nd
}

// 将空白字符串转换为空指针，同时字符串本身也将转换为指针类型。
func EmptyToNil(val string) *string {
	if len(val) == 0 {
		return nil
	}
	return &val
}

// 将一个`decimal.NullDecimal`类型的值转换为字符串指针，并且在转换的过程中设定其展示位数，默认使用银行进位法。
func NullDecimalToString(d decimal.NullDecimal, precision ...int32) *string {
	precision = append(precision, 2)
	if !d.Valid {
		return nil
	}
	return lo.ToPtr(d.Decimal.StringFixedBank(precision[0]))
}

// 将sql.NullTime转换为*string
func NullTime2PointerString(nullTime sql.NullTime) *string {
	var strPtr *string
	if nullTime.Valid {
		str := nullTime.Time.String()
		strPtr = &str
		return strPtr
	} else {
		strPtr = nil
		return strPtr
	}
}

// 该方法用于将时间解析为字符串指针
func TimeToStringPtr(t *time.Time) *string {
	if t == nil {
		return nil
	}

	timeStr := t.Format("2006-01-02 15:04:05")
	return &timeStr
}