refactor: optimize fsm code

Author: colin404

internal/nightwatch/watcher/user/event.go

@@ -95,11 +95,8 @@ func NewUserEventAfterEvent(store store.Interface) fsm.Callback {
 		user.Status = event.FSM.Current()
 		if err := store.UserCenter().Users().Update(ctx, user); err != nil {
 			log.Errorw(err, "Failed to update status into database", "event", event.Event)
-		}
-
-		if user.Status == known.UserStatusDeleted {
-			// We can add some lark card here in the future.
-			log.Infow("Finish to handle user", "event", event.Event, "username", user.Username)
+			event.Err = err
+			return
 		}
 	}
 }

internal/nightwatch/watcher/user/fsm.go

@@ -32,12 +32,10 @@ func NewFSM(initial string, w *userWatcher) *fsm.FSM {
 			// Define need events.
 			{Name: known.UserStatusNeedActive, Src: []string{known.UserStatusNeedActive}, Dst: known.UserStatusActived},
 			{Name: known.UserStatusNeedDisable, Src: []string{known.UserStatusNeedDisable}, Dst: known.UserStatusDisabled},
-			// After disabling the user, they can be deleted, and the FSM will automatically transition to the next deleted state.
-			// I have decided not to delete the user in the code, so the state transition here is commented out.
-			// {Name: known.UserStatusDisabled, Src: []string{known.UserStatusDisabled}, Dst: known.UserStatusDeleted},
+			{Name: known.UserStatusDisabled, Src: []string{known.UserStatusDisabled}, Dst: known.UserStatusDeleted},
 		},
 		fsm.Callbacks{
-			known.UserStatusActived:   NewActiveUserCallback(w.store),
+			known.UserStatusActived:  NewActiveUserCallback(w.store),
 			known.UserStatusDisabled: NewDisableUserCallback(w.store),
 			known.UserStatusDeleted:  NewDeleteUserCallback(w.store),
 			// log, alert, save to stoer, etc for all events.
@@ -46,3 +44,12 @@ func NewFSM(initial string, w *userWatcher) *fsm.FSM {
 		},
 	)
 }
+
+func filterFSMError(err error) error {
+	switch err.(type) {
+	case fsm.NoTransitionError:
+		return nil
+	default:
+		return err
+	}
+}

internal/nightwatch/watcher/user/watcher.go

@@ -30,10 +30,10 @@ type userWatcher struct {
 	maxWorkers int64
 }
 
-// User is a struct that represents a user finite state machine.
-type User struct {
-	*model.UserM
-	*fsm.FSM
+// UserStateMachine is a struct that represents a user finite state machine.
+type UserStateMachine struct {
+	UserM *model.UserM
+	FSM   *fsm.FSM
 }
 
 // Run runs the watcher.
@@ -51,6 +51,9 @@ func (w *userWatcher) Run() {
 		known.UserStatusBlacklisted,
 		known.UserStatusNeedActive,
 		known.UserStatusNeedDisable,
+		// After disabling the user, they can be deleted, and the FSM will automatically transition to the next deleted state.
+		// I have decided not to delete the user in the code, so the state transition here is commented out.
+		// known.UserStatusDisabled,
 	}
 
 	wp := workerpool.New(int(w.maxWorkers))
@@ -62,12 +65,18 @@ func (w *userWatcher) Run() {
 		wp.Submit(func() {
 			ctx := onexx.NewUserM(context.Background(), user)
 
-			u := &User{UserM: user, FSM: NewFSM(user.Status, w)}
-			if err := u.Event(ctx, user.Status); err != nil {
+			usm := &UserStateMachine{UserM: user, FSM: NewFSM(user.Status, w)}
+			if err := usm.FSM.Event(ctx, user.Status); err != nil {
 				log.Errorw(err, "Failed to event user", "username", user.Username, "status", user.Status)
 				return
 			}
 
+			// When the entire state machine reaches the final state, print a message and send a notification.
+			if usm.FSM.Current() == known.UserStatusDeleted {
+				// We can add some lark card here in the future.
+				log.Infow("Finish to handle user", "username", usm.UserM.Username)
+			}
+
 			return
 		})
 	}