fix: update user nickname;

feat: add database/kafka.

internal/controller/user.go

@@ -5,17 +5,19 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/loveuer/nf/nft/resp"
-	"github.com/spf13/cast"
-	"gorm.io/gorm"
 	"strings"
 	"time"
+
 	"ultone/internal/database/cache"
 	"ultone/internal/database/db"
 	"ultone/internal/log"
 	"ultone/internal/model"
 	"ultone/internal/opt"
 	"ultone/internal/tool"
+
+	"github.com/loveuer/nf/nft/resp"
+	"github.com/spf13/cast"
+	"gorm.io/gorm"
 )
 
 type userController interface {
@@ -25,7 +27,7 @@ type userController interface {
 	CacheToken(ctx context.Context, token string, user *model.User) error
 	RmToken(ctx context.Context, token string) error
 	RmUserCache(ctx context.Context, id uint64) error
-	DeleteUser(ctx context.Context, id uint64) error
+	DeleteUser(ctx context.Context, target *model.User) error
 }
 
 type uc struct{}
@@ -135,30 +137,26 @@ func (u uc) RmUserCache(ctx context.Context, id uint64) error {
 	return cache.Client.Del(tool.Timeout(3), key)
 }
 
-func (u uc) DeleteUser(ctx context.Context, id uint64) error {
+func (u uc) DeleteUser(ctx context.Context, target *model.User) error {
 	var (
 		err      error
 		now      = time.Now()
-		username = "CONCAT(username, '@del')"
+		username = fmt.Sprintf("%s@%d", target.Username, now.UnixMilli())
 	)
 
-	if opt.Cfg.DB.Type == "sqlite" {
-		username = "username || '@del'"
-	}
-
 	if err = db.Default.Session(tool.Timeout(5)).
 		Model(&model.User{}).
-		Where("id = ?", id).
+		Where("id = ?", target.Id).
 		Updates(map[string]any{
 			"deleted_at": now.UnixMilli(),
-			"username":   gorm.Expr(username),
+			"username":   username,
 		}).Error; err != nil {
 		return resp.NewError(500, "", err, nil)
 	}
 
 	if opt.EnableUserCache {
-		if err = u.RmUserCache(ctx, id); err != nil {
-			log.Warn(ctx, "controller.DeleteUser: rm user=%d cache err=%v", id, err)
+		if err = u.RmUserCache(ctx, target.Id); err != nil {
+			log.Warn(ctx, "controller.DeleteUser: rm user=%d cache err=%v", target.Id, err)
 		}
 	}
 

internal/database/db/client.go

@@ -3,25 +3,32 @@ package db
 import (
 	"context"
 	"io"
+
 	"ultone/internal/opt"
 	"ultone/internal/tool"
 
 	"gorm.io/gorm"
 )
 
-var (
-	Default *Client
+var Default *Client
+
+type DBType string
+
+const (
+	DBTypeSqlite   = "sqlite"
+	DBTypeMysql    = "mysql"
+	DBTypePostgres = "postgres"
 )
 
 type Client struct {
 	ctx       context.Context
 	cli       *gorm.DB
-	ttype     string
+	dbType    DBType
 	cfgSqlite *cfgSqlite
 }
 
-func (c *Client) Type() string {
-	return c.ttype
+func (c *Client) Type() DBType {
+	return c.dbType
 }
 
 func (c *Client) Session(ctxs ...context.Context) *gorm.DB {
@@ -49,7 +56,7 @@ func (c *Client) Close() {
 // Dump
 // Only for sqlite with mem mode to dump data to bytes(io.Reader)
 func (c *Client) Dump() (reader io.ReadSeekCloser, ok bool) {
-	if c.ttype != "sqlite" {
+	if c.dbType != DBTypeSqlite {
 		return nil, false
 	}
 

internal/database/db/db_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 func TestOpen(t *testing.T) {
-	myClient, err := New(context.TODO(), "sqlite::", OptSqliteByMem())
+	myClient, err := New(context.TODO(), "sqlite::", OptSqliteByMem(nil))
 	if err != nil {
 		t.Fatalf("TestOpen: New err = %v", err)
 	}
@@ -37,7 +37,7 @@ func TestOpen(t *testing.T) {
 			t.Fatalf("TestOpen: ReadAll err = %v", err)
 		}
 
-		os.WriteFile("dump.db", bs, 0644)
+		os.WriteFile("dump.db", bs, 0o644)
 	}
 
 	myClient.Close()

internal/database/db/new.go

@@ -11,35 +11,38 @@ import (
 )
 
 func New(ctx context.Context, uri string, opts ...Option) (*Client, error) {
-	strs := strings.Split(uri, "::")
+	parts := strings.SplitN(uri, "::", 2)
 
-	if len(strs) != 2 {
+	if len(parts) != 2 {
 		return nil, fmt.Errorf("db.Init: opt db uri invalid: %s", uri)
 	}
 
-	c := &Client{ttype: strs[0], cfgSqlite: &cfgSqlite{fsType: "file"}}
+	c := &Client{cfgSqlite: &cfgSqlite{fsType: "file"}}
 	for _, f := range opts {
 		f(c)
 	}
 
 	var (
 		err error
-		dsn = strs[1]
+		dsn = parts[1]
 	)
 
-	switch strs[0] {
+	switch parts[0] {
 	case "sqlite":
+		c.dbType = DBTypeSqlite
 		err = openSqlite(c, dsn)
 	case "mysql":
+		c.dbType = DBTypeMysql
 		c.cli, err = gorm.Open(mysql.Open(dsn))
 	case "postgres":
+		c.dbType = DBTypePostgres
 		c.cli, err = gorm.Open(postgres.Open(dsn))
 	default:
-		return nil, fmt.Errorf("db type only support: [sqlite, mysql, postgres], unsupported db type: %s", strs[0])
+		return nil, fmt.Errorf("db type only support: [sqlite, mysql, postgres], unsupported db type: %s", parts[0])
 	}
 
 	if err != nil {
-		return nil, fmt.Errorf("db.Init: open %s with dsn:%s, err: %w", strs[0], dsn, err)
+		return nil, fmt.Errorf("db.Init: open %s with dsn:%s, err: %w", parts[0], dsn, err)
 	}
 
 	return c, nil

internal/database/kafka/client.go

@@ -0,0 +1,74 @@
+package kafka
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	"ultone/internal/interfaces"
+
+	"github.com/loveuer/nf/nft/log"
+	kfkgo "github.com/segmentio/kafka-go"
+	"github.com/segmentio/kafka-go/sasl"
+)
+
+var Client *client
+
+type client struct {
+	sync.Mutex
+	ctx          context.Context
+	d            *kfkgo.Dialer
+	topic        string
+	partition    int
+	reconnection bool
+	mechanism    sasl.Mechanism
+	address      string
+	logger       interfaces.Logger
+	writer       *kfkgo.Writer
+}
+
+func Init(address string, opts ...OptionFn) error {
+	c, err := New(address, opts...)
+	if err != nil {
+		return err
+	}
+
+	Client = c
+
+	return nil
+}
+
+func New(address string, opts ...OptionFn) (*client, error) {
+	c := &client{}
+
+	if address == "" {
+		return nil, fmt.Errorf("address required")
+	}
+
+	for _, fn := range opts {
+		fn(c)
+	}
+
+	c.address = address
+
+	if c.ctx == nil {
+		c.ctx = context.Background()
+	}
+
+	if c.logger == nil {
+		c.logger = log.New()
+	}
+
+	dia := &kfkgo.Dialer{
+		Timeout: 30 * time.Second,
+	}
+
+	if c.mechanism != nil {
+		dia.SASLMechanism = c.mechanism
+	}
+
+	c.d = dia
+
+	return c, nil
+}

internal/database/kafka/client_test.go

@@ -0,0 +1,87 @@
+package kafka
+
+import (
+	"context"
+	"os/signal"
+	"syscall"
+	"testing"
+	"time"
+
+	"ultone/internal/tool"
+
+	"github.com/loveuer/nf/nft/log"
+)
+
+func TestKafka(t *testing.T) {
+	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
+	defer cancel()
+
+	client, err := New("10.220.10.15:9092",
+		WithTopic("test_zyp"),
+		WithPlainAuth("admin", "Yhblsqt@!."),
+		WithReconnection(),
+	)
+	if err != nil {
+		t.Fatal(1, err)
+	}
+
+	ch, err := client.ReadMessage(ctx, ReadConfig{})
+	if err != nil {
+		t.Fatal(2, err)
+	}
+
+	for msg := range ch {
+		if msg.err != nil {
+			t.Logf("[Error] [TestKafka] msg.err = %v", msg.err)
+			continue
+		}
+
+		t.Logf("[Info ] [TestKafka] [time = %s] [msg.topic = %s] [msg.key = %s] [msg.value = %s]", time.Now().Format("060102T150405"), msg.Topic, string(msg.Key), string(msg.Value))
+	}
+}
+
+func TestKafkaWrite(t *testing.T) {
+	log.SetLogLevel(log.LogLevelDebug)
+	client, err := New("10.220.10.15:9092",
+		WithTopic("test_zyp"),
+		WithPlainAuth("admin", "Yhblsqt@!."),
+		WithReconnection(),
+	)
+	if err != nil {
+		t.Fatal(1, err)
+	}
+
+	if err = client.WriteMessages(tool.Timeout(5),
+		&Payload{
+			Key:   []byte(time.Now().Format("2006/01/02 15:04:05")),
+			Value: []byte(tool.RandomString(16)),
+		},
+		&Payload{
+			Key:   []byte(time.Now().Format("2006/01/02 15:04:05")),
+			Value: []byte(tool.RandomString(16)),
+		},
+		&Payload{
+			Key:   []byte(time.Now().Format("2006/01/02 15:04:05")),
+			Value: []byte(tool.RandomString(16)),
+		},
+	); err != nil {
+		t.Log(2, err)
+	}
+
+	if err = client.WriteMessages(context.Background(),
+		&Payload{
+			Key:   []byte(time.Now().Format("2006/01/02 15:04:05")),
+			Value: []byte(tool.RandomString(16)),
+		},
+		&Payload{
+			Key:   []byte(time.Now().Format("2006/01/02 15:04:05")),
+			Value: []byte(tool.RandomString(16)),
+		},
+		&Payload{
+			Key:   []byte(time.Now().Format("2006/01/02 15:04:05")),
+			Value: []byte(tool.RandomString(16)),
+		},
+	); err != nil {
+		t.Log(3, err)
+	}
+}

internal/database/kafka/consumer.go

@@ -0,0 +1,158 @@
+package kafka
+
+import (
+	"context"
+	"errors"
+	"io"
+	"time"
+
+	"ultone/internal/tool"
+
+	kfkgo "github.com/segmentio/kafka-go"
+)
+
+type Message struct {
+	kfkgo.Message
+	err error
+}
+
+type ReadConfig struct {
+	// MaxBytes: read buffer max bytes
+	/*
+	  - default 1MB
+	*/
+	MaxBytes int
+
+	// FirstOffset
+	/*
+		    - false: use last offset(-1)
+			- true:  use first offset(-2)
+			- default: false
+			- more: [about group offset](https://github.com/segmentio/kafka-go/blob/main/reader.go#L16)
+	*/
+	FirstOffset bool
+
+	Topic string
+	Group string
+
+	// Timeout: every read max duration
+	/*
+	  - default: 30 seconds (same with kafka-go default)
+	*/
+	Timeout int
+}
+
+var defaultReadConfig = ReadConfig{
+	// 1 MB
+	MaxBytes: 1e6,
+	Group:    "default",
+	Timeout:  30,
+}
+
+func (c *client) ReadMessage(ctx context.Context, configs ...ReadConfig) (<-chan *Message, error) {
+	var (
+		err   error
+		cfg   = ReadConfig{}
+		ch    = make(chan *Message, 1)
+		retry = 0
+	)
+
+	if len(configs) > 0 {
+		cfg = configs[0]
+	}
+
+	if cfg.Group == "" {
+		cfg.Group = defaultReadConfig.Group
+	}
+
+	if cfg.MaxBytes <= 0 {
+		cfg.MaxBytes = defaultReadConfig.MaxBytes
+	}
+
+	if cfg.Timeout <= 0 {
+		cfg.Timeout = defaultReadConfig.Timeout
+	}
+
+	offset := kfkgo.LastOffset
+	if cfg.FirstOffset {
+		offset = kfkgo.FirstOffset
+	}
+
+	rc := kfkgo.ReaderConfig{
+		Brokers:     []string{c.address},
+		GroupID:     cfg.Group,
+		Topic:       c.topic,
+		Partition:   c.partition,
+		Dialer:      c.d,
+		MaxBytes:    cfg.MaxBytes,
+		StartOffset: offset,
+	}
+
+	if err = rc.Validate(); err != nil {
+		return nil, err
+	}
+
+	r := kfkgo.NewReader(rc)
+
+	go func() {
+		defer func() {
+			close(ch)
+			_ = r.Close()
+		}()
+	Loop:
+		for {
+			select {
+			case <-ctx.Done():
+				close(ch)
+				_ = r.Close()
+				return
+			default:
+				msg, err := r.ReadMessage(tool.TimeoutCtx(ctx, cfg.Timeout))
+				if err != nil {
+					if errors.Is(err, context.DeadlineExceeded) {
+						continue Loop
+					}
+
+					if errors.Is(err, context.Canceled) {
+						return
+					}
+
+					c.logger.Debug("kafka.ReadMessage: err = %s", err.Error())
+
+					if errors.Is(err, io.EOF) {
+						return
+					}
+
+					if errors.Is(err, io.ErrShortBuffer) {
+						ch <- &Message{
+							Message: msg,
+							err:     err,
+						}
+						continue Loop
+					}
+
+					if c.reconnection {
+						retry++
+						c.logger.Warn("kafka.ReadMessage: reconnection after 30 seconds, times = %d, err = %s", retry, err.Error())
+						time.Sleep(30 * time.Second)
+						continue Loop
+					}
+
+					ch <- &Message{
+						Message: msg,
+						err:     err,
+					}
+
+					return
+				}
+
+				ch <- &Message{
+					Message: msg,
+					err:     nil,
+				}
+			}
+		}
+	}()
+
+	return ch, nil
+}

internal/database/kafka/option.go

@@ -0,0 +1,42 @@
+package kafka
+
+import (
+	"ultone/internal/interfaces"
+
+	"github.com/segmentio/kafka-go/sasl/plain"
+)
+
+type OptionFn func(*client)
+
+func WithPlainAuth(username, password string) OptionFn {
+	return func(c *client) {
+		c.mechanism = plain.Mechanism{
+			Username: username,
+			Password: password,
+		}
+	}
+}
+
+func WithTopic(topic string) OptionFn {
+	return func(c *client) {
+		c.topic = topic
+	}
+}
+
+func WithPartition(partition int) OptionFn {
+	return func(c *client) {
+		c.partition = partition
+	}
+}
+
+func WithReconnection() OptionFn {
+	return func(c *client) {
+		c.reconnection = true
+	}
+}
+
+func WithLogger(logger interfaces.Logger) OptionFn {
+	return func(c *client) {
+		c.logger = logger
+	}
+}

internal/database/kafka/writer.go

@@ -0,0 +1,82 @@
+package kafka
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"time"
+
+	kfkgo "github.com/segmentio/kafka-go"
+)
+
+type Payload struct {
+	Key        []byte
+	Value      []byte
+	Headers    []kfkgo.Header
+	WriterData any
+}
+
+func (c *client) WriteMessages(ctx context.Context, payloads ...*Payload) error {
+	if len(payloads) == 0 {
+		return nil
+	}
+
+	times := 0
+Retry:
+	if c.writer == nil {
+		c.Lock()
+		c.writer = &kfkgo.Writer{
+			Addr:         kfkgo.TCP(c.address),
+			Topic:        c.topic,
+			Balancer:     &kfkgo.Hash{},
+			WriteTimeout: 0,
+			RequiredAcks: 0,
+			Async:        false,
+			Transport: &kfkgo.Transport{
+				DialTimeout: 30 * time.Second,
+				TLS:         &tls.Config{InsecureSkipVerify: true}, // todo
+				SASL:        c.mechanism,
+				Context:     c.ctx,
+			},
+			AllowAutoTopicCreation: true,
+		}
+		c.Unlock()
+	}
+
+	now := time.Now()
+
+	msgs := make([]kfkgo.Message, 0, len(payloads))
+
+	for _, item := range payloads {
+		msgs = append(msgs, kfkgo.Message{
+			Key:        item.Key,
+			Value:      item.Value,
+			Headers:    item.Headers,
+			WriterData: item.WriterData,
+			Time:       now,
+		})
+	}
+
+	context.WithoutCancel(ctx)
+	if err := c.writer.WriteMessages(ctx, msgs...); err != nil {
+		if errors.Is(err, context.DeadlineExceeded) {
+			goto HandleError
+		}
+
+		if c.reconnection {
+			times++
+			c.logger.Warn("kafka.WriteMessage: reconnection after 30 seconds, times = %d, err = %s", times, err.Error())
+			time.Sleep(30 * time.Second)
+			c.Lock()
+			c.writer = nil
+			c.Unlock()
+			goto Retry
+		}
+
+	HandleError:
+		c.logger.Warn("kafka.WriteMessage: err = %s", err.Error())
+		return err
+	}
+
+	return nil
+}

internal/handler/user.go

@@ -3,12 +3,9 @@ package handler
 import (
 	"errors"
 	"fmt"
-	"github.com/loveuer/nf"
-	"github.com/loveuer/nf/nft/resp"
-	"github.com/samber/lo"
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
+	"net/http"
 	"time"
+
 	"ultone/internal/controller"
 	"ultone/internal/database/cache"
 	"ultone/internal/database/db"
@@ -17,6 +14,12 @@ import (
 	"ultone/internal/opt"
 	"ultone/internal/sqlType"
 	"ultone/internal/tool"
+
+	"github.com/loveuer/nf"
+	"github.com/loveuer/nf/nft/resp"
+	"github.com/samber/lo"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
 )
 
 func AuthLogin(c *nf.Ctx) error {
@@ -140,6 +143,7 @@ func UserUpdate(c *nf.Ctx) error {
 	type Req struct {
 		OldPassword string `json:"old_password"`
 		NewPassword string `json:"new_password"`
+		Nickname    string `json:"nickname"`
 	}
 
 	type Model struct {
@@ -147,11 +151,13 @@ func UserUpdate(c *nf.Ctx) error {
 	}
 
 	var (
-		ok   bool
-		err  error
-		req  = new(Req)
-		user *model.User
-		m    = new(Model)
+		ok      bool
+		err     error
+		req     = new(Req)
+		user    *model.User
+		m       = new(Model)
+		updates = make(map[string]any)
+		changes = make(map[string]any)
 	)
 
 	if user, ok = c.Locals("user").(*model.User); !ok {
@@ -162,42 +168,55 @@ func UserUpdate(c *nf.Ctx) error {
 		return resp.Resp400(c, err)
 	}
 
-	if req.OldPassword == "" || req.NewPassword == "" {
-		return resp.Resp400(c, req)
+	if err = c.BodyParser(&changes); err != nil {
+		return resp.Resp400(c, err)
 	}
 
-	if err = tool.CheckPassword(req.NewPassword); err != nil {
-		return resp.Resp400(c, req, err.Error())
+	if _, ok = changes["nickname"]; ok {
+		updates["nickname"] = req.Nickname
 	}
 
-	if err = db.Default.Session(tool.Timeout(3)).
-		Select("password").
-		Model(&model.User{}).
-		Where("username = ?", user.Username).
-		Where("deleted_at = 0").
-		Take(m).
-		Error; err != nil {
-		return resp.Resp500(c, err.Error())
+	if req.OldPassword != "" && req.NewPassword != "" {
+		if err = tool.CheckPassword(req.NewPassword); err != nil {
+			return resp.Resp400(c, req, err.Error())
+		}
+
+		if err = db.Default.Session(tool.Timeout(3)).
+			Select("password").
+			Model(&model.User{}).
+			Where("username = ?", user.Username).
+			Where("deleted_at = 0").
+			Take(m).
+			Error; err != nil {
+			return resp.Resp500(c, err.Error())
+		}
+
+		if !tool.ComparePassword(req.OldPassword, m.Password) {
+			return resp.Resp400(c, nil, "原密码错误")
+		}
+
+		updates["password"] = tool.NewPassword(req.NewPassword)
 	}
 
-	if !tool.ComparePassword(req.OldPassword, m.Password) {
-		return resp.Resp400(c, nil, "原密码错误")
+	if len(updates) == 0 {
+		return resp.Resp400(c, nf.Map{"req": req, "reason": "nothing to update"}, "没有需要更新的内容")
 	}
 
 	if err = db.Default.Session(tool.Timeout(5)).
 		Model(&model.User{}).
 		Where("id = ?", user.Id).
-		Update("password", tool.NewPassword(req.NewPassword)).
+		Updates(updates).
 		Error; err != nil {
 		return resp.Resp500(c, err.Error())
 	}
 
-	_ = controller.UserController.RmUserCache(c.Context(), user.Id)
-	// todo delete token
+	if _, ok = updates["password"]; ok {
+		_ = controller.UserController.RmUserCache(c.Context(), user.Id)
+		c.SetHeader("Set-Cookie", fmt.Sprintf("%s=;Path=/", opt.CookieName))
+		return c.Redirect(opt.LoginURL, http.StatusFound)
+	}
 
-	c.SetHeader("Set-Cookie", fmt.Sprintf("%s=;Path=/", opt.CookieName))
-
-	return resp.Resp200(c, nil, "修改成功, 请重新登录")
+	return resp.Resp200(c, nil, "修改成功")
 }
 
 func ManageUserList(c *nf.Ctx) error {
@@ -553,7 +572,7 @@ func ManageUserDelete(c *nf.Ctx) error {
 		return resp.Resp403(c, nil)
 	}
 
-	if err = controller.UserController.DeleteUser(c.Context(), target.Id); err != nil {
+	if err = controller.UserController.DeleteUser(c.Context(), target); err != nil {
 		return resp.RespError(c, err)
 	}
 

internal/interfaces/logger.go

@@ -5,3 +5,10 @@ type OpLogger interface {
 	Render(content map[string]any) (string, error)
 	Template() string
 }
+
+type Logger interface {
+	Debug(msg string, data ...any)
+	Info(msg string, data ...any)
+	Warn(msg string, data ...any)
+	Error(msg string, data ...any)
+}

internal/opt/var.go

@@ -41,6 +41,8 @@ const (
 	OpLogWriteDurationSecond = 5
 
 	LocalTraceKey = "X-Trace-Id"
+
+	LoginURL = "/login"
 )
 
 var (