Migrate "User.UpdateMfaActive" to Sync by default (#11566)

api4/user_test.go

@@ -2114,8 +2114,8 @@ func TestUserLoginMFAFlow(t *testing.T) {
 		assert.Nil(t, err)
 
 		// Fake user has MFA enabled
-		if result := <-th.Server.Store.User().UpdateMfaActive(th.BasicUser.Id, true); result.Err != nil {
+		if err = th.Server.Store.User().UpdateMfaActive(th.BasicUser.Id, true); err != nil {
-			t.Fatal(result.Err)
+			t.Fatal(err)
 		}
 
 		if err = th.Server.Store.User().UpdateMfaSecret(th.BasicUser.Id, secret.Secret); err != nil {
@@ -2146,8 +2146,8 @@ func TestUserLoginMFAFlow(t *testing.T) {
 		assert.Nil(t, err)
 
 		// Fake user has MFA enabled
-		if result := <-th.Server.Store.User().UpdateMfaActive(th.BasicUser.Id, true); result.Err != nil {
+		if err = th.Server.Store.User().UpdateMfaActive(th.BasicUser.Id, true); err != nil {
-			t.Fatal(result.Err)
+			t.Fatal(err)
 		}
 
 		if err = th.Server.Store.User().UpdateMfaSecret(th.BasicUser.Id, secret.Secret); err != nil {
@@ -4352,8 +4352,8 @@ func TestLoginLockout(t *testing.T) {
 	CheckErrorMessage(t, resp, "api.user.check_user_login_attempts.too_many.app_error")
 
 	// Fake user has MFA enabled
-	if result := <-th.Server.Store.User().UpdateMfaActive(th.BasicUser2.Id, true); result.Err != nil {
+	if err := th.Server.Store.User().UpdateMfaActive(th.BasicUser2.Id, true); err != nil {
-		t.Fatal(result.Err)
+		t.Fatal(err)
 	}
 	_, resp = th.Client.LoginWithMFA(th.BasicUser2.Email, th.BasicUser2.Password, "000000")
 	CheckErrorMessage(t, resp, "api.user.check_user_mfa.bad_code.app_error")
@@ -4367,8 +4367,8 @@ func TestLoginLockout(t *testing.T) {
 	CheckErrorMessage(t, resp, "api.user.check_user_login_attempts.too_many.app_error")
 
 	// Fake user has MFA disabled
-	if result := <-th.Server.Store.User().UpdateMfaActive(th.BasicUser2.Id, false); result.Err != nil {
+	if err := th.Server.Store.User().UpdateMfaActive(th.BasicUser2.Id, false); err != nil {
-		t.Fatal(result.Err)
+		t.Fatal(err)
 	}
 
 	//Check if lock is active

services/mfa/mfa.go

@@ -99,8 +99,8 @@ func (m *Mfa) Activate(user *model.User, token string) *model.AppError {
 		return model.NewAppError("Activate", "mfa.activate.bad_token.app_error", nil, "", http.StatusUnauthorized)
 	}
 
-	if result := <-m.Store.User().UpdateMfaActive(user.Id, true); result.Err != nil {
+	if err = m.Store.User().UpdateMfaActive(user.Id, true); err != nil {
-		return model.NewAppError("Activate", "mfa.activate.save_active.app_error", nil, result.Err.Error(), http.StatusInternalServerError)
+		return model.NewAppError("Activate", "mfa.activate.save_active.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
 	return nil
@@ -111,15 +111,14 @@ func (m *Mfa) Deactivate(userId string) *model.AppError {
 		return err
 	}
 
-	achan := m.Store.User().UpdateMfaActive(userId, false)
 	schan := make(chan *model.AppError, 1)
 	go func() {
 		schan <- m.Store.User().UpdateMfaSecret(userId, "")
 		close(schan)
 	}()
 
-	if result := <-achan; result.Err != nil {
+	if err := m.Store.User().UpdateMfaActive(userId, false); err != nil {
-		return model.NewAppError("Deactivate", "mfa.deactivate.save_active.app_error", nil, result.Err.Error(), http.StatusInternalServerError)
+		return model.NewAppError("Deactivate", "mfa.deactivate.save_active.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
 	if err := <-schan; err != nil {

store/sqlstore/user_store.go

@@ -303,16 +303,14 @@ func (us SqlUserStore) UpdateMfaSecret(userId, secret string) *model.AppError {
 	return nil
 }
 
-func (us SqlUserStore) UpdateMfaActive(userId string, active bool) store.StoreChannel {
+func (us SqlUserStore) UpdateMfaActive(userId string, active bool) *model.AppError {
-	return store.Do(func(result *store.StoreResult) {
+	updateAt := model.GetMillis()
-		updateAt := model.GetMillis()
 
-		if _, err := us.GetMaster().Exec("UPDATE Users SET MfaActive = :Active, UpdateAt = :UpdateAt WHERE Id = :UserId", map[string]interface{}{"Active": active, "UpdateAt": updateAt, "UserId": userId}); err != nil {
+	if _, err := us.GetMaster().Exec("UPDATE Users SET MfaActive = :Active, UpdateAt = :UpdateAt WHERE Id = :UserId", map[string]interface{}{"Active": active, "UpdateAt": updateAt, "UserId": userId}); err != nil {
-			result.Err = model.NewAppError("SqlUserStore.UpdateMfaActive", "store.sql_user.update_mfa_active.app_error", nil, "id="+userId+", "+err.Error(), http.StatusInternalServerError)
+		return model.NewAppError("SqlUserStore.UpdateMfaActive", "store.sql_user.update_mfa_active.app_error", nil, "id="+userId+", "+err.Error(), http.StatusInternalServerError)
-		} else {
+	}
-			result.Data = userId
+
-		}
+	return nil
-	})
 }
 
 func (us SqlUserStore) Get(id string) (*model.User, *model.AppError) {

store/store.go

@@ -257,7 +257,7 @@ type UserStore interface {
 	UpdateUpdateAt(userId string) (int64, *model.AppError)
 	UpdateAuthData(userId string, service string, authData *string, email string, resetMfa bool) (string, *model.AppError)
 	UpdateMfaSecret(userId, secret string) *model.AppError
-	UpdateMfaActive(userId string, active bool) StoreChannel
+	UpdateMfaActive(userId string, active bool) *model.AppError
 	Get(id string) (*model.User, *model.AppError)
 	GetAll() ([]*model.User, *model.AppError)
 	ClearCaches()

store/storetest/mocks/UserStore.go

@@ -1127,15 +1127,15 @@ func (_m *UserStore) UpdateLastPictureUpdate(userId string) *model.AppError {
 }
 
 // UpdateMfaActive provides a mock function with given fields: userId, active
-func (_m *UserStore) UpdateMfaActive(userId string, active bool) store.StoreChannel {
+func (_m *UserStore) UpdateMfaActive(userId string, active bool) *model.AppError {
 	ret := _m.Called(userId, active)
 
-	var r0 store.StoreChannel
+	var r0 *model.AppError
-	if rf, ok := ret.Get(0).(func(string, bool) store.StoreChannel); ok {
+	if rf, ok := ret.Get(0).(func(string, bool) *model.AppError); ok {
 		r0 = rf(userId, active)
 	} else {
 		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(store.StoreChannel)
+			r0 = ret.Get(0).(*model.AppError)
 		}
 	}
 

store/storetest/user_store.go

@@ -1987,16 +1987,16 @@ func testUserStoreUpdateMfaActive(t *testing.T, ss store.Store) {
 
 	time.Sleep(100 * time.Millisecond)
 
-	if err = (<-ss.User().UpdateMfaActive(u1.Id, true)).Err; err != nil {
+	if err = ss.User().UpdateMfaActive(u1.Id, true); err != nil {
 		t.Fatal(err)
 	}
 
-	if err = (<-ss.User().UpdateMfaActive(u1.Id, false)).Err; err != nil {
+	if err = ss.User().UpdateMfaActive(u1.Id, false); err != nil {
 		t.Fatal(err)
 	}
 
 	// should pass, no update will occur though
-	if err = (<-ss.User().UpdateMfaActive("junk", true)).Err; err != nil {
+	if err = ss.User().UpdateMfaActive("junk", true); err != nil {
 		t.Fatal(err)
 	}
 }