code_log.go

package l

import (
	"errors"
	"fmt"
)

/*
本包ERROR函数使用
1.在首位传入错误码，函数自动使用首位的错误码
2.在使用WrapError,WrapErrorf,GetError,GetError这些函数会返回一个携带错误码的error（ErrorCode）
3.可以不在函数中传入错误码，可传入一个携带错误码的error（ErrorCode），以下函数会自动解析传入函数中的error中的错误码
4.如果以下函数不传入错误码，也不传入携带错误码的error（ErrorCode），会正常打印普通error信息
*/

func Error(msgs ...interface{}) {
	if logger.logLevel > LevelError {
		return
	}
	code, firstArg := getErrCode(msgs...)
	if code != "" {
		msgs = append(msgs, code)
	}
	if firstArg && len(msgs) >= 2 {
		logMsg("ERROR", msgs[1:]...)
		return
	}
	logMsg("ERROR", msgs...)
}

func Errorf(msgs ...interface{}) {
	if logger.logLevel > LevelError {
		return
	}
	code, firstArg := getErrCode(msgs...)
	switch len(msgs) {
	case 0:
		logMsg("ERROR", msgs...)
	case 1:
		if code != "" && !firstArg {
			msgs = append(msgs, code)
		}
		logMsg("ERROR", msgs...)
	case 2:
		if firstArg {
			msgs = append(msgs, code)
			logMsg("ERROR", msgs[1:]...)
			return
		}
		if _, ok := msgs[0].(string); ok {
			logMsg("ERROR", fmt.Sprintf(msgs[0].(string), msgs[1:]...), code)
		}
	default:
		if firstArg {
			if _, ok := msgs[1].(string); ok {
				logMsg("ERROR", fmt.Sprintf(msgs[1].(string), msgs[2:]...), code)
			}
			return
		}
		if _, ok := msgs[0].(string); ok {
			logMsg("ERROR", fmt.Sprintf(msgs[0].(string), msgs[1:]...), code)
		}
	}
}

func WrapError(msgs ...interface{}) error {
	code, firstArg := getErrCode(msgs...)
	fmtStr := getFmtMsg(msgs...)
	if firstArg {
		fmtStr = getFmtMsg(msgs[1:]...)
	}
	if logger.logLevel <= LevelError {
		logMsg("ERROR", fmtStr, code)
	}
	return ErrorCode{
		code,
		errors.New(fmtStr),
	}
}

func WrapErrorf(msgs ...interface{}) error {
	code, firstArg := getErrCode(msgs...)
	var fmtStr string
	switch len(msgs) {
	case 0:
		fmtStr = ""
	case 1:
		if firstArg {
			fmtStr = ""
			break
		}
		fmtStr = fmt.Sprintf("%v", msgs[0])
	case 2:
		if firstArg {
			fmtStr = fmt.Sprintf("%v", msgs[1])
			break
		}
		if _, ok := msgs[0].(string); ok {
			fmtStr = fmt.Sprintf(msgs[0].(string), msgs[1:]...)
		}
	default:
		if firstArg {
			if _, ok := msgs[1].(string); ok {
				fmtStr = fmt.Sprintf(msgs[1].(string), msgs[2:]...)
			}
			break
		}
		if _, ok := msgs[0].(string); ok {
			fmtStr = fmt.Sprintf(msgs[0].(string), msgs[1:]...)
		}
	}
	if logger.logLevel <= LevelError {
		logMsg("ERROR", fmtStr, code)
	}
	return ErrorCode{
		code,
		errors.New(fmtStr),
	}
}

func GetError(msgs ...interface{}) error {
	code, firstArg := getErrCode(msgs...)
	if code == "" {
		return wrapError(msgs...)
	}
	fmtStr := getFmtMsg(msgs...)
	if firstArg {
		fmtStr = getFmtMsg(msgs[1:]...)
	}
	return ErrorCode{
		code,
		errors.New(fmtStr),
	}
}

func GetErrorf(msgs ...interface{}) error {
	code, firstArg := getErrCode(msgs...)
	var fmtStr string
	switch len(msgs) {
	case 0:
		fmtStr = ""
	case 1:
		if firstArg {
			fmtStr = ""
			break
		}
		fmtStr = fmt.Sprintf("%v", msgs[0])
	case 2:
		if firstArg {
			fmtStr = fmt.Sprintf("%v", msgs[1])
			break
		}
		if _, ok := msgs[0].(string); ok {
			fmtStr = fmt.Sprintf(msgs[0].(string), msgs[1:]...)
		}
	default:
		if firstArg {
			if _, ok := msgs[1].(string); ok {
				fmtStr = fmt.Sprintf(msgs[1].(string), msgs[2:]...)
			}
			break
		}
		if _, ok := msgs[0].(string); ok {
			fmtStr = fmt.Sprintf(msgs[0].(string), msgs[1:]...)
		}
	}
	return ErrorCode{
		code,
		errors.New(fmtStr),
	}
}

// 获取错误码，优先获取手动输入的错误码，其次获取解析error中的错误码
func getErrCode(msgs ...interface{}) (errCode ErrCode, firstArg bool) {
	for i, v := range msgs {
		if code, ok := v.(ErrCode); ok && i == 0 {
			errCode = code
			firstArg = true
			break
		}
		if _, ok := v.(ErrorCode); !ok {
			continue
		}
		errCode = v.(ErrorCode).Code
	}
	return errCode, firstArg
}

func getFmtMsg(msgs ...interface{}) string {
	fmtStr := ""
	for i, msg := range msgs {
		if i == 0 {
			fmtStr = fmt.Sprintf("%+v", msg)
		} else {
			fmtStr = fmt.Sprintf("%s %+v", fmtStr, msg)
		}
	}
	return fmtStr
}