add reverse:for v1.0.8 test

go.mod

@@ -3,9 +3,7 @@ module code.fnuoos.com/go_rely_warehouse/zyos_go_o2o_business.git
 go 1.15
 
 require (
-	github.com/go-redis/redis v6.15.9+incompatible
 	github.com/go-sql-driver/mysql v1.6.0
-	github.com/gomodule/redigo/redis v0.0.1
 	go.uber.org/zap v1.23.0
 	xorm.io/xorm v1.3.1
 )

o2o/add_store_commission.go

@@ -4,7 +4,6 @@ import (
 	"code.fnuoos.com/go_rely_warehouse/zyos_go_o2o_business.git/db"
 	"code.fnuoos.com/go_rely_warehouse/zyos_go_o2o_business.git/db/model"
 	zhios_o2o_business_utils "code.fnuoos.com/go_rely_warehouse/zyos_go_o2o_business.git/utils"
-	zhios_o2o_business_logx "code.fnuoos.com/go_rely_warehouse/zyos_go_o2o_business.git/utils/logx"
 	"strconv"
 	"time"
 	"xorm.io/xorm"
@@ -102,13 +101,11 @@ func SettleStoreCommission(eg *xorm.Engine, session *xorm.Session, args map[stri
 		affected, err := db.MerchantUpdateWithSession(session, merchant, "amount")
 		has, errs := session.Insert(&o2oFinUserFlow)
 		if affected == 0 || err != nil || errs != nil || has == 0 {
-			_ = zhios_o2o_business_logx.Warn(err)
 			return false
 		}
 		relate.SettleTime = time.Now()
 		update, err := session.Where("id=?", relate.Id).Cols("settle_time").Update(relate)
 		if update == 0 || err != nil {
-			_ = zhios_o2o_business_logx.Warn(err)
 			return false
 		}
 	}
@@ -163,13 +160,11 @@ func DeductStoreCommission(eg *xorm.Engine, session *xorm.Session, args map[stri
 		affected, err := db.MerchantUpdateWithSession(session, merchant, "amount")
 		has, errs := session.Insert(&o2oFinUserFlow)
 		if affected == 0 || err != nil || errs != nil || has == 0 {
-			_ = zhios_o2o_business_logx.Warn(err)
 			return false
 		}
 		relate.SettleTime = time.Time{}
 		update, err := session.Where("id=?", relate.Id).Cols("settle_time").Update(relate)
 		if update == 0 || err != nil {
-			_ = zhios_o2o_business_logx.Warn(err)
 			return false
 		}
 	}

o2o/add_store_fans.go

@@ -4,7 +4,6 @@ import (
 	"code.fnuoos.com/go_rely_warehouse/zyos_go_o2o_business.git/db"
 	"code.fnuoos.com/go_rely_warehouse/zyos_go_o2o_business.git/db/model"
 	zhios_o2o_business_utils "code.fnuoos.com/go_rely_warehouse/zyos_go_o2o_business.git/utils"
-	zhios_o2o_business_logx "code.fnuoos.com/go_rely_warehouse/zyos_go_o2o_business.git/utils/logx"
 	"time"
 	"xorm.io/xorm"
 )
@@ -54,6 +53,5 @@ func DealCommonPayStoreFans(eg *xorm.Engine, uid string, storeId, isUpdate, rema
 		err = db.UpdateStoreFans(eg, storeFans)
 	}
 	if err != nil {
-		zhios_o2o_business_logx.Warn(err, "處理通用支付中的店鋪粉絲-失敗！")
 	}
 }

utils/logx/log.go

@@ -1,209 +0,0 @@
-package zhios_o2o_business_logx
-
-import (
-	"os"
-	"strings"
-	"time"
-
-	"go.uber.org/zap"
-	"go.uber.org/zap/zapcore"
-)
-
-type LogConfig struct {
-	AppName         string `yaml:"app_name" json:"app_name" toml:"app_name"`
-	Level           string `yaml:"level" json:"level" toml:"level"`
-	StacktraceLevel string `yaml:"stacktrace_level" json:"stacktrace_level" toml:"stacktrace_level"`
-	IsStdOut        bool   `yaml:"is_stdout" json:"is_stdout" toml:"is_stdout"`
-	TimeFormat      string `yaml:"time_format" json:"time_format" toml:"time_format"` // second, milli, nano, standard, iso,
-	Encoding        string `yaml:"encoding" json:"encoding" toml:"encoding"`          // console, json
-	Skip            int    `yaml:"skip" json:"skip" toml:"skip"`
-
-	IsFileOut   bool   `yaml:"is_file_out" json:"is_file_out" toml:"is_file_out"`
-	FileDir     string `yaml:"file_dir" json:"file_dir" toml:"file_dir"`
-	FileName    string `yaml:"file_name" json:"file_name" toml:"file_name"`
-	FileMaxSize int    `yaml:"file_max_size" json:"file_max_size" toml:"file_max_size"`
-	FileMaxAge  int    `yaml:"file_max_age" json:"file_max_age" toml:"file_max_age"`
-}
-
-var (
-	l    *LogX = defaultLogger()
-	conf *LogConfig
-)
-
-// default logger setting
-func defaultLogger() *LogX {
-	conf = &LogConfig{
-		Level:           "debug",
-		StacktraceLevel: "error",
-		IsStdOut:        true,
-		TimeFormat:      "standard",
-		Encoding:        "console",
-		Skip:            2,
-	}
-	writers := []zapcore.WriteSyncer{os.Stdout}
-	lg, lv := newZapLogger(setLogLevel(conf.Level), setLogLevel(conf.StacktraceLevel), conf.Encoding, conf.TimeFormat, conf.Skip, zapcore.NewMultiWriteSyncer(writers...))
-	zap.RedirectStdLog(lg)
-	return &LogX{logger: lg, atomLevel: lv}
-}
-
-// create a new zaplog logger
-func newZapLogger(level, stacktrace zapcore.Level, encoding, timeType string, skip int, output zapcore.WriteSyncer) (*zap.Logger, *zap.AtomicLevel) {
-	encCfg := zapcore.EncoderConfig{
-		TimeKey:        "T",
-		LevelKey:       "L",
-		NameKey:        "N",
-		CallerKey:      "C",
-		MessageKey:     "M",
-		StacktraceKey:  "S",
-		LineEnding:     zapcore.DefaultLineEnding,
-		EncodeCaller:   zapcore.ShortCallerEncoder,
-		EncodeDuration: zapcore.NanosDurationEncoder,
-		EncodeLevel:    zapcore.LowercaseLevelEncoder,
-	}
-	setTimeFormat(timeType, &encCfg) // set time type
-	atmLvl := zap.NewAtomicLevel()   // set level
-	atmLvl.SetLevel(level)
-	encoder := zapcore.NewJSONEncoder(encCfg) // 确定encoder格式
-	if encoding == "console" {
-		encoder = zapcore.NewConsoleEncoder(encCfg)
-	}
-	return zap.New(zapcore.NewCore(encoder, output, atmLvl), zap.AddCaller(), zap.AddStacktrace(stacktrace), zap.AddCallerSkip(skip)), &atmLvl
-}
-
-// set log level
-func setLogLevel(lvl string) zapcore.Level {
-	switch strings.ToLower(lvl) {
-	case "panic":
-		return zapcore.PanicLevel
-	case "fatal":
-		return zapcore.FatalLevel
-	case "error":
-		return zapcore.ErrorLevel
-	case "warn", "warning":
-		return zapcore.WarnLevel
-	case "info":
-		return zapcore.InfoLevel
-	default:
-		return zapcore.DebugLevel
-	}
-}
-
-// set time format
-func setTimeFormat(timeType string, z *zapcore.EncoderConfig) {
-	switch strings.ToLower(timeType) {
-	case "iso": // iso8601 standard
-		z.EncodeTime = zapcore.ISO8601TimeEncoder
-	case "sec": // only for unix second, without millisecond
-		z.EncodeTime = func(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
-			enc.AppendInt64(t.Unix())
-		}
-	case "second": // unix second, with millisecond
-		z.EncodeTime = zapcore.EpochTimeEncoder
-	case "milli", "millisecond": // millisecond
-		z.EncodeTime = zapcore.EpochMillisTimeEncoder
-	case "nano", "nanosecond": // nanosecond
-		z.EncodeTime = zapcore.EpochNanosTimeEncoder
-	default: // standard format
-		z.EncodeTime = func(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
-			enc.AppendString(t.Format("2006-01-02 15:04:05.000"))
-		}
-	}
-}
-
-func GetLevel() string {
-	switch l.atomLevel.Level() {
-	case zapcore.PanicLevel:
-		return "panic"
-	case zapcore.FatalLevel:
-		return "fatal"
-	case zapcore.ErrorLevel:
-		return "error"
-	case zapcore.WarnLevel:
-		return "warn"
-	case zapcore.InfoLevel:
-		return "info"
-	default:
-		return "debug"
-	}
-}
-
-func SetLevel(lvl string) {
-	l.atomLevel.SetLevel(setLogLevel(lvl))
-}
-
-// temporary add call skip
-func AddCallerSkip(skip int) *LogX {
-	l.logger.WithOptions(zap.AddCallerSkip(skip))
-	return l
-}
-
-// permanent add call skip
-func AddDepth(skip int) *LogX {
-	l.logger = l.logger.WithOptions(zap.AddCallerSkip(skip))
-	return l
-}
-
-// permanent add options
-func AddOptions(opts ...zap.Option) *LogX {
-	l.logger = l.logger.WithOptions(opts...)
-	return l
-}
-
-func AddField(k string, v interface{}) {
-	l.logger.With(zap.Any(k, v))
-}
-
-func AddFields(fields map[string]interface{}) *LogX {
-	for k, v := range fields {
-		l.logger.With(zap.Any(k, v))
-	}
-	return l
-}
-
-// Normal log
-func Debug(e interface{}, args ...interface{}) error {
-	return l.Debug(e, args...)
-}
-func Info(e interface{}, args ...interface{}) error {
-	return l.Info(e, args...)
-}
-func Warn(e interface{}, args ...interface{}) error {
-	return l.Warn(e, args...)
-}
-func Error(e interface{}, args ...interface{}) error {
-	return l.Error(e, args...)
-}
-func Panic(e interface{}, args ...interface{}) error {
-	return l.Panic(e, args...)
-}
-func Fatal(e interface{}, args ...interface{}) error {
-	return l.Fatal(e, args...)
-}
-
-// Format logs
-func Debugf(format string, args ...interface{}) error {
-	return l.Debugf(format, args...)
-}
-func Infof(format string, args ...interface{}) error {
-	return l.Infof(format, args...)
-}
-func Warnf(format string, args ...interface{}) error {
-	return l.Warnf(format, args...)
-}
-func Errorf(format string, args ...interface{}) error {
-	return l.Errorf(format, args...)
-}
-func Panicf(format string, args ...interface{}) error {
-	return l.Panicf(format, args...)
-}
-func Fatalf(format string, args ...interface{}) error {
-	return l.Fatalf(format, args...)
-}
-
-func formatFieldMap(m FieldMap) []Field {
-	var res []Field
-	for k, v := range m {
-		res = append(res, zap.Any(k, v))
-	}
-	return res
-}

utils/logx/sugar.go

@@ -1,192 +0,0 @@
-package zhios_o2o_business_logx
-
-import (
-	"errors"
-	"fmt"
-	"strconv"
-
-	"go.uber.org/zap"
-)
-
-type LogX struct {
-	logger    *zap.Logger
-	atomLevel *zap.AtomicLevel
-}
-
-type Field = zap.Field
-type FieldMap map[string]interface{}
-
-// 判断其他类型--start
-func getFields(msg string, format bool, args ...interface{}) (string, []Field) {
-	var str []interface{}
-	var fields []zap.Field
-	if len(args) > 0 {
-		for _, v := range args {
-			if f, ok := v.(Field); ok {
-				fields = append(fields, f)
-			} else if f, ok := v.(FieldMap); ok {
-				fields = append(fields, formatFieldMap(f)...)
-			} else {
-				str = append(str, AnyToString(v))
-			}
-		}
-		if format {
-			return fmt.Sprintf(msg, str...), fields
-		}
-		str = append([]interface{}{msg}, str...)
-		return fmt.Sprintln(str...), fields
-	}
-	return msg, []Field{}
-}
-
-func (l *LogX) Debug(s interface{}, args ...interface{}) error {
-	es, e := checkErr(s)
-	if es != "" {
-		msg, field := getFields(es, false, args...)
-		l.logger.Debug(msg, field...)
-	}
-	return e
-}
-func (l *LogX) Info(s interface{}, args ...interface{}) error {
-	es, e := checkErr(s)
-	if es != "" {
-		msg, field := getFields(es, false, args...)
-		l.logger.Info(msg, field...)
-	}
-	return e
-}
-func (l *LogX) Warn(s interface{}, args ...interface{}) error {
-	es, e := checkErr(s)
-	if es != "" {
-		msg, field := getFields(es, false, args...)
-		l.logger.Warn(msg, field...)
-	}
-	return e
-}
-func (l *LogX) Error(s interface{}, args ...interface{}) error {
-	es, e := checkErr(s)
-	if es != "" {
-		msg, field := getFields(es, false, args...)
-		l.logger.Error(msg, field...)
-	}
-	return e
-}
-func (l *LogX) DPanic(s interface{}, args ...interface{}) error {
-	es, e := checkErr(s)
-	if es != "" {
-		msg, field := getFields(es, false, args...)
-		l.logger.DPanic(msg, field...)
-	}
-	return e
-}
-func (l *LogX) Panic(s interface{}, args ...interface{}) error {
-	es, e := checkErr(s)
-	if es != "" {
-		msg, field := getFields(es, false, args...)
-		l.logger.Panic(msg, field...)
-	}
-	return e
-}
-func (l *LogX) Fatal(s interface{}, args ...interface{}) error {
-	es, e := checkErr(s)
-	if es != "" {
-		msg, field := getFields(es, false, args...)
-		l.logger.Fatal(msg, field...)
-	}
-	return e
-}
-
-func checkErr(s interface{}) (string, error) {
-	switch e := s.(type) {
-	case error:
-		return e.Error(), e
-	case string:
-		return e, errors.New(e)
-	case []byte:
-		return string(e), nil
-	default:
-		return "", nil
-	}
-}
-
-func (l *LogX) LogError(err error) error {
-	return l.Error(err.Error())
-}
-
-func (l *LogX) Debugf(msg string, args ...interface{}) error {
-	s, f := getFields(msg, true, args...)
-	l.logger.Debug(s, f...)
-	return errors.New(s)
-}
-
-func (l *LogX) Infof(msg string, args ...interface{}) error {
-	s, f := getFields(msg, true, args...)
-	l.logger.Info(s, f...)
-	return errors.New(s)
-}
-
-func (l *LogX) Warnf(msg string, args ...interface{}) error {
-	s, f := getFields(msg, true, args...)
-	l.logger.Warn(s, f...)
-	return errors.New(s)
-}
-
-func (l *LogX) Errorf(msg string, args ...interface{}) error {
-	s, f := getFields(msg, true, args...)
-	l.logger.Error(s, f...)
-	return errors.New(s)
-}
-
-func (l *LogX) DPanicf(msg string, args ...interface{}) error {
-	s, f := getFields(msg, true, args...)
-	l.logger.DPanic(s, f...)
-	return errors.New(s)
-}
-
-func (l *LogX) Panicf(msg string, args ...interface{}) error {
-	s, f := getFields(msg, true, args...)
-	l.logger.Panic(s, f...)
-	return errors.New(s)
-}
-
-func (l *LogX) Fatalf(msg string, args ...interface{}) error {
-	s, f := getFields(msg, true, args...)
-	l.logger.Fatal(s, f...)
-	return errors.New(s)
-}
-
-func AnyToString(raw interface{}) string {
-	switch i := raw.(type) {
-	case []byte:
-		return string(i)
-	case int:
-		return strconv.FormatInt(int64(i), 10)
-	case int64:
-		return strconv.FormatInt(i, 10)
-	case float32:
-		return strconv.FormatFloat(float64(i), 'f', 2, 64)
-	case float64:
-		return strconv.FormatFloat(i, 'f', 2, 64)
-	case uint:
-		return strconv.FormatInt(int64(i), 10)
-	case uint8:
-		return strconv.FormatInt(int64(i), 10)
-	case uint16:
-		return strconv.FormatInt(int64(i), 10)
-	case uint32:
-		return strconv.FormatInt(int64(i), 10)
-	case uint64:
-		return strconv.FormatInt(int64(i), 10)
-	case int8:
-		return strconv.FormatInt(int64(i), 10)
-	case int16:
-		return strconv.FormatInt(int64(i), 10)
-	case int32:
-		return strconv.FormatInt(int64(i), 10)
-	case string:
-		return i
-	case error:
-		return i.Error()
-	}
-	return fmt.Sprintf("%#v", raw)
-}