MM-33913: Fix read-after-write issues with team member (#17173)

During LDAP sync, we would call AddTeamMember which had a read-after-write issue
where we would create a team member but then immediately after that
query the team member.

The same pattern was found in:
AddTeamMember
AddTeamMembers
AddTeamMemberByToken

To fix this, we just return the inserted team member from AddUserToTeam and use that
instead of query GetTeamMember again.

```release-note
NONE
```

https://mattermost.atlassian.net/browse/MM-33913

Co-authored-by: Mattermod <mattermod@users.noreply.github.com>

api4/apitestlib.go

@@ -781,7 +781,7 @@ func (th *TestHelper) UpdateActiveUser(user *model.User, active bool) {
 func (th *TestHelper) LinkUserToTeam(user *model.User, team *model.Team) {
 	utils.DisableDebugLogForTest()
 
-	err := th.App.JoinUserToTeam(team, user, "")
+	_, err := th.App.JoinUserToTeam(team, user, "")
 	if err != nil {
 		panic(err)
 	}

api4/user_test.go

@@ -378,7 +378,7 @@ func TestCreateUserWebSocketEvent(t *testing.T) {
 		guest, err := th.App.CreateGuest(guest)
 		require.Nil(t, err)
 
-		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, guest.Id, "")
+		_, _, err = th.App.AddUserToTeam(th.BasicTeam.Id, guest.Id, "")
 		require.Nil(t, err)
 
 		_, err = th.App.AddUserToChannel(guest, th.BasicChannel)

app/app_iface.go

@@ -376,10 +376,10 @@ type AppIface interface {
 	AddTeamMemberByToken(userID, tokenID string) (*model.TeamMember, *model.AppError)
 	AddTeamMembers(teamID string, userIDs []string, userRequestorId string, graceful bool) ([]*model.TeamMemberWithError, *model.AppError)
 	AddUserToChannel(user *model.User, channel *model.Channel) (*model.ChannelMember, *model.AppError)
-	AddUserToTeam(teamID string, userID string, userRequestorId string) (*model.Team, *model.AppError)
+	AddUserToTeam(teamID string, userID string, userRequestorId string) (*model.Team, *model.TeamMember, *model.AppError)
-	AddUserToTeamByInviteId(inviteId string, userID string) (*model.Team, *model.AppError)
+	AddUserToTeamByInviteId(inviteId string, userID string) (*model.Team, *model.TeamMember, *model.AppError)
 	AddUserToTeamByTeamId(teamID string, user *model.User) *model.AppError
-	AddUserToTeamByToken(userID string, tokenID string) (*model.Team, *model.AppError)
+	AddUserToTeamByToken(userID string, tokenID string) (*model.Team, *model.TeamMember, *model.AppError)
 	AdjustImage(file io.Reader) (*bytes.Buffer, *model.AppError)
 	AllowOAuthAppAccessToUser(userID string, authRequest *model.AuthorizeRequest) (string, *model.AppError)
 	AppendFile(fr io.Reader, path string) (int64, *model.AppError)
@@ -799,7 +799,7 @@ type AppIface interface {
 	IsUserSignUpAllowed() *model.AppError
 	JoinChannel(channel *model.Channel, userID string) *model.AppError
 	JoinDefaultChannels(teamID string, user *model.User, shouldBeAdmin bool, userRequestorId string) *model.AppError
-	JoinUserToTeam(team *model.Team, user *model.User, userRequestorId string) *model.AppError
+	JoinUserToTeam(team *model.Team, user *model.User, userRequestorId string) (*model.TeamMember, *model.AppError)
 	Ldap() einterfaces.LdapInterface
 	LeaveChannel(channelID string, userID string) *model.AppError
 	LeaveTeam(team *model.Team, user *model.User, requestorId string) *model.AppError

app/channel.go

@@ -1373,6 +1373,10 @@ func (a *App) addUserToChannel(user *model.User, channel *model.Channel) (*model
 }
 
 func (a *App) AddUserToChannel(user *model.User, channel *model.Channel) (*model.ChannelMember, *model.AppError) {
+	// We have to query master here because this is called during LDAP sync from:
+	// a.createDefaultChannelMemberships -> a.AddTeamMember -> a.AddChannelMember
+	// So we get a teamMember right after adding a team member which leads to a failure.
+	// TODO: pass the team member to this method.
 	teamMember, nErr := a.Srv().Store.Team().GetMember(sqlstore.WithMaster(context.Background()), channel.TeamId, user.Id)
 	if nErr != nil {
 		var nfErr *store.ErrNotFound

app/channel_test.go

@@ -81,11 +81,11 @@ func TestRemoveAllDeactivatedMembersFromChannel(t *testing.T) {
 		th.App.PermanentDeleteTeam(team)
 	}()
 
-	_, err = th.App.AddUserToTeam(team.Id, th.BasicUser.Id, "")
+	_, _, err = th.App.AddUserToTeam(team.Id, th.BasicUser.Id, "")
 	require.Nil(t, err)
 
 	deacivatedUser := th.CreateUser()
-	_, err = th.App.AddUserToTeam(team.Id, deacivatedUser.Id, "")
+	_, _, err = th.App.AddUserToTeam(team.Id, deacivatedUser.Id, "")
 	require.Nil(t, err)
 	_, err = th.App.AddUserToChannel(deacivatedUser, channel)
 	require.Nil(t, err)
@@ -118,13 +118,13 @@ func TestMoveChannel(t *testing.T) {
 			th.App.PermanentDeleteTeam(targetTeam)
 		}()
 
-		_, err = th.App.AddUserToTeam(sourceTeam.Id, th.BasicUser.Id, "")
+		_, _, err = th.App.AddUserToTeam(sourceTeam.Id, th.BasicUser.Id, "")
 		require.Nil(t, err)
 
-		_, err = th.App.AddUserToTeam(sourceTeam.Id, th.BasicUser2.Id, "")
+		_, _, err = th.App.AddUserToTeam(sourceTeam.Id, th.BasicUser2.Id, "")
 		require.Nil(t, err)
 
-		_, err = th.App.AddUserToTeam(targetTeam.Id, th.BasicUser.Id, "")
+		_, _, err = th.App.AddUserToTeam(targetTeam.Id, th.BasicUser.Id, "")
 		require.Nil(t, err)
 
 		_, err = th.App.AddUserToChannel(th.BasicUser, channel1)
@@ -136,7 +136,7 @@ func TestMoveChannel(t *testing.T) {
 		err = th.App.MoveChannel(targetTeam, channel1, th.BasicUser)
 		require.NotNil(t, err, "Should have failed due to mismatched members.")
 
-		_, err = th.App.AddUserToTeam(targetTeam.Id, th.BasicUser2.Id, "")
+		_, _, err = th.App.AddUserToTeam(targetTeam.Id, th.BasicUser2.Id, "")
 		require.Nil(t, err)
 
 		err = th.App.MoveChannel(targetTeam, channel1, th.BasicUser)
@@ -148,7 +148,7 @@ func TestMoveChannel(t *testing.T) {
 		channel2 := th.CreateChannel(sourceTeam)
 		defer th.App.PermanentDeleteChannel(channel2)
 
-		_, err = th.App.AddUserToTeam(sourceTeam.Id, deacivatedUser.Id, "")
+		_, _, err = th.App.AddUserToTeam(sourceTeam.Id, deacivatedUser.Id, "")
 		require.Nil(t, err)
 		_, err = th.App.AddUserToChannel(th.BasicUser, channel2)
 		require.Nil(t, err)
@@ -234,11 +234,11 @@ func TestRemoveUsersFromChannelNotMemberOfTeam(t *testing.T) {
 		th.App.PermanentDeleteTeam(team2)
 	}()
 
-	_, err := th.App.AddUserToTeam(team.Id, th.BasicUser.Id, "")
+	_, _, err := th.App.AddUserToTeam(team.Id, th.BasicUser.Id, "")
 	require.Nil(t, err)
-	_, err = th.App.AddUserToTeam(team2.Id, th.BasicUser.Id, "")
+	_, _, err = th.App.AddUserToTeam(team2.Id, th.BasicUser.Id, "")
 	require.Nil(t, err)
-	_, err = th.App.AddUserToTeam(team.Id, th.BasicUser2.Id, "")
+	_, _, err = th.App.AddUserToTeam(team.Id, th.BasicUser2.Id, "")
 	require.Nil(t, err)
 
 	_, err = th.App.AddUserToChannel(th.BasicUser, channel1)
@@ -1098,7 +1098,7 @@ func TestUpdateChannelMemberRolesChangingGuest(t *testing.T) {
 		user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
 		ruser, _ := th.App.CreateGuest(&user)
 
-		_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.Nil(t, err)
 
 		_, err = th.App.AddUserToChannel(ruser, th.BasicChannel)
@@ -1112,7 +1112,7 @@ func TestUpdateChannelMemberRolesChangingGuest(t *testing.T) {
 		user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
 		ruser, _ := th.App.CreateUser(&user)
 
-		_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.Nil(t, err)
 
 		_, err = th.App.AddUserToChannel(ruser, th.BasicChannel)
@@ -1126,7 +1126,7 @@ func TestUpdateChannelMemberRolesChangingGuest(t *testing.T) {
 		user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
 		ruser, _ := th.App.CreateUser(&user)
 
-		_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.Nil(t, err)
 
 		_, err = th.App.AddUserToChannel(ruser, th.BasicChannel)
@@ -1140,7 +1140,7 @@ func TestUpdateChannelMemberRolesChangingGuest(t *testing.T) {
 		user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
 		ruser, _ := th.App.CreateGuest(&user)
 
-		_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.Nil(t, err)
 
 		_, err = th.App.AddUserToChannel(ruser, th.BasicChannel)
@@ -1157,7 +1157,7 @@ func TestUpdateChannelMemberRolesChangingGuest(t *testing.T) {
 		user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
 		ruser, _ := th.App.CreateGuest(&user)
 
-		_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.Nil(t, err)
 
 		_, err = th.App.AddUserToChannel(ruser, th.BasicChannel)

app/helper_test.go

@@ -400,7 +400,7 @@ func (th *TestHelper) CreateMessagePost(channel *model.Channel, message string)
 func (th *TestHelper) LinkUserToTeam(user *model.User, team *model.Team) {
 	utils.DisableDebugLogForTest()
 
-	err := th.App.JoinUserToTeam(team, user, "")
+	_, err := th.App.JoinUserToTeam(team, user, "")
 	if err != nil {
 		panic(err)
 	}

app/opentracing/opentracing_layer.go

@@ -479,7 +479,7 @@ func (a *OpenTracingAppLayer) AddUserToChannel(user *model.User, channel *model.
 	return resultVar0, resultVar1
 }
 
-func (a *OpenTracingAppLayer) AddUserToTeam(teamID string, userID string, userRequestorId string) (*model.Team, *model.AppError) {
+func (a *OpenTracingAppLayer) AddUserToTeam(teamID string, userID string, userRequestorId string) (*model.Team, *model.TeamMember, *model.AppError) {
 	origCtx := a.ctx
 	span, newCtx := tracing.StartSpanWithParentByContext(a.ctx, "app.AddUserToTeam")
 
@@ -491,17 +491,17 @@ func (a *OpenTracingAppLayer) AddUserToTeam(teamID string, userID string, userRe
 	}()
 
 	defer span.Finish()
-	resultVar0, resultVar1 := a.app.AddUserToTeam(teamID, userID, userRequestorId)
+	resultVar0, resultVar1, resultVar2 := a.app.AddUserToTeam(teamID, userID, userRequestorId)
 
-	if resultVar1 != nil {
+	if resultVar2 != nil {
-		span.LogFields(spanlog.Error(resultVar1))
+		span.LogFields(spanlog.Error(resultVar2))
 		ext.Error.Set(span, true)
 	}
 
-	return resultVar0, resultVar1
+	return resultVar0, resultVar1, resultVar2
 }
 
-func (a *OpenTracingAppLayer) AddUserToTeamByInviteId(inviteId string, userID string) (*model.Team, *model.AppError) {
+func (a *OpenTracingAppLayer) AddUserToTeamByInviteId(inviteId string, userID string) (*model.Team, *model.TeamMember, *model.AppError) {
 	origCtx := a.ctx
 	span, newCtx := tracing.StartSpanWithParentByContext(a.ctx, "app.AddUserToTeamByInviteId")
 
@@ -513,14 +513,14 @@ func (a *OpenTracingAppLayer) AddUserToTeamByInviteId(inviteId string, userID st
 	}()
 
 	defer span.Finish()
-	resultVar0, resultVar1 := a.app.AddUserToTeamByInviteId(inviteId, userID)
+	resultVar0, resultVar1, resultVar2 := a.app.AddUserToTeamByInviteId(inviteId, userID)
 
-	if resultVar1 != nil {
+	if resultVar2 != nil {
-		span.LogFields(spanlog.Error(resultVar1))
+		span.LogFields(spanlog.Error(resultVar2))
 		ext.Error.Set(span, true)
 	}
 
-	return resultVar0, resultVar1
+	return resultVar0, resultVar1, resultVar2
 }
 
 func (a *OpenTracingAppLayer) AddUserToTeamByTeamId(teamID string, user *model.User) *model.AppError {
@@ -545,7 +545,7 @@ func (a *OpenTracingAppLayer) AddUserToTeamByTeamId(teamID string, user *model.U
 	return resultVar0
 }
 
-func (a *OpenTracingAppLayer) AddUserToTeamByToken(userID string, tokenID string) (*model.Team, *model.AppError) {
+func (a *OpenTracingAppLayer) AddUserToTeamByToken(userID string, tokenID string) (*model.Team, *model.TeamMember, *model.AppError) {
 	origCtx := a.ctx
 	span, newCtx := tracing.StartSpanWithParentByContext(a.ctx, "app.AddUserToTeamByToken")
 
@@ -557,14 +557,14 @@ func (a *OpenTracingAppLayer) AddUserToTeamByToken(userID string, tokenID string
 	}()
 
 	defer span.Finish()
-	resultVar0, resultVar1 := a.app.AddUserToTeamByToken(userID, tokenID)
+	resultVar0, resultVar1, resultVar2 := a.app.AddUserToTeamByToken(userID, tokenID)
 
-	if resultVar1 != nil {
+	if resultVar2 != nil {
-		span.LogFields(spanlog.Error(resultVar1))
+		span.LogFields(spanlog.Error(resultVar2))
 		ext.Error.Set(span, true)
 	}
 
-	return resultVar0, resultVar1
+	return resultVar0, resultVar1, resultVar2
 }
 
 func (a *OpenTracingAppLayer) AdjustImage(file io.Reader) (*bytes.Buffer, *model.AppError) {
@@ -10675,7 +10675,7 @@ func (a *OpenTracingAppLayer) JoinDefaultChannels(teamID string, user *model.Use
 	return resultVar0
 }
 
-func (a *OpenTracingAppLayer) JoinUserToTeam(team *model.Team, user *model.User, userRequestorId string) *model.AppError {
+func (a *OpenTracingAppLayer) JoinUserToTeam(team *model.Team, user *model.User, userRequestorId string) (*model.TeamMember, *model.AppError) {
 	origCtx := a.ctx
 	span, newCtx := tracing.StartSpanWithParentByContext(a.ctx, "app.JoinUserToTeam")
 
@@ -10687,14 +10687,14 @@ func (a *OpenTracingAppLayer) JoinUserToTeam(team *model.Team, user *model.User,
 	}()
 
 	defer span.Finish()
-	resultVar0 := a.app.JoinUserToTeam(team, user, userRequestorId)
+	resultVar0, resultVar1 := a.app.JoinUserToTeam(team, user, userRequestorId)
 
-	if resultVar0 != nil {
+	if resultVar1 != nil {
-		span.LogFields(spanlog.Error(resultVar0))
+		span.LogFields(spanlog.Error(resultVar1))
 		ext.Error.Set(span, true)
 	}
 
-	return resultVar0
+	return resultVar0, resultVar1
 }
 
 func (a *OpenTracingAppLayer) LeaveChannel(channelID string, userID string) *model.AppError {

app/slashcommands/command_invite_test.go

@@ -41,7 +41,7 @@ func TestInviteProvider(t *testing.T) {
 		Description: "a test bot",
 	})
 	require.Nil(t, err)
-	_, err = th.App.AddUserToTeam(th.BasicTeam.Id, bot2.UserId, basicUser3.Id)
+	_, _, err = th.App.AddUserToTeam(th.BasicTeam.Id, bot2.UserId, basicUser3.Id)
 	require.Nil(t, err)
 
 	bot3, err := th.App.CreateBot(&model.Bot{
@@ -50,7 +50,7 @@ func TestInviteProvider(t *testing.T) {
 		Description: "a test bot",
 	})
 	require.Nil(t, err)
-	_, err = th.App.AddUserToTeam(th.BasicTeam.Id, bot3.UserId, basicUser3.Id)
+	_, _, err = th.App.AddUserToTeam(th.BasicTeam.Id, bot3.UserId, basicUser3.Id)
 	require.Nil(t, err)
 	err = th.App.RemoveUserFromTeam(th.BasicTeam.Id, bot3.UserId, basicUser3.Id)
 	require.Nil(t, err)

app/slashcommands/helper_test.go

@@ -347,7 +347,7 @@ func (th *TestHelper) createPost(channel *model.Channel) *model.Post {
 func (th *TestHelper) linkUserToTeam(user *model.User, team *model.Team) {
 	utils.DisableDebugLogForTest()
 
-	err := th.App.JoinUserToTeam(team, user, "")
+	_, err := th.App.JoinUserToTeam(team, user, "")
 	if err != nil {
 		panic(err)
 	}

app/team.go

@@ -65,7 +65,7 @@ func (a *App) CreateTeamWithUser(team *model.Team, userID string) (*model.Team,
 		return nil, err
 	}
 
-	if err = a.JoinUserToTeam(rteam, user, ""); err != nil {
+	if _, err := a.JoinUserToTeam(rteam, user, ""); err != nil {
 		return nil, err
 	}
 
@@ -480,7 +480,7 @@ func (a *App) sendUpdatedMemberRoleEvent(userID string, member *model.TeamMember
 	a.Publish(message)
 }
 
-func (a *App) AddUserToTeam(teamID string, userID string, userRequestorId string) (*model.Team, *model.AppError) {
+func (a *App) AddUserToTeam(teamID string, userID string, userRequestorId string) (*model.Team, *model.TeamMember, *model.AppError) {
 	tchan := make(chan store.StoreResult, 1)
 	go func() {
 		team, err := a.Srv().Store.Team().Get(teamID)
@@ -500,9 +500,9 @@ func (a *App) AddUserToTeam(teamID string, userID string, userRequestorId string
 		var nfErr *store.ErrNotFound
 		switch {
 		case errors.As(result.NErr, &nfErr):
-			return nil, model.NewAppError("AddUserToTeam", "app.team.get.find.app_error", nil, nfErr.Error(), http.StatusNotFound)
+			return nil, nil, model.NewAppError("AddUserToTeam", "app.team.get.find.app_error", nil, nfErr.Error(), http.StatusNotFound)
 		default:
-			return nil, model.NewAppError("AddUserToTeam", "app.team.get.finding.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
+			return nil, nil, model.NewAppError("AddUserToTeam", "app.team.get.finding.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
 		}
 	}
 	team := result.Data.(*model.Team)
@@ -512,18 +512,19 @@ func (a *App) AddUserToTeam(teamID string, userID string, userRequestorId string
 		var nfErr *store.ErrNotFound
 		switch {
 		case errors.As(result.NErr, &nfErr):
-			return nil, model.NewAppError("AddUserToTeam", MissingAccountError, nil, nfErr.Error(), http.StatusNotFound)
+			return nil, nil, model.NewAppError("AddUserToTeam", MissingAccountError, nil, nfErr.Error(), http.StatusNotFound)
 		default:
-			return nil, model.NewAppError("AddUserToTeam", "app.user.get.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
+			return nil, nil, model.NewAppError("AddUserToTeam", "app.user.get.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
 		}
 	}
 	user := result.Data.(*model.User)
 
-	if err := a.JoinUserToTeam(team, user, userRequestorId); err != nil {
+	teamMember, err := a.JoinUserToTeam(team, user, userRequestorId)
-		return nil, err
+	if err != nil {
+		return nil, nil, err
 	}
 
-	return team, nil
+	return team, teamMember, nil
 }
 
 func (a *App) AddUserToTeamByTeamId(teamID string, user *model.User) *model.AppError {
@@ -538,22 +539,25 @@ func (a *App) AddUserToTeamByTeamId(teamID string, user *model.User) *model.AppE
 		}
 	}
 
-	return a.JoinUserToTeam(team, user, "")
+	if _, err := a.JoinUserToTeam(team, user, ""); err != nil {
+		return err
+	}
+	return nil
 }
 
-func (a *App) AddUserToTeamByToken(userID string, tokenID string) (*model.Team, *model.AppError) {
+func (a *App) AddUserToTeamByToken(userID string, tokenID string) (*model.Team, *model.TeamMember, *model.AppError) {
 	token, err := a.Srv().Store.Token().GetByToken(tokenID)
 	if err != nil {
-		return nil, model.NewAppError("AddUserToTeamByToken", "api.user.create_user.signup_link_invalid.app_error", nil, err.Error(), http.StatusBadRequest)
+		return nil, nil, model.NewAppError("AddUserToTeamByToken", "api.user.create_user.signup_link_invalid.app_error", nil, err.Error(), http.StatusBadRequest)
 	}
 
 	if token.Type != TokenTypeTeamInvitation && token.Type != TokenTypeGuestInvitation {
-		return nil, model.NewAppError("AddUserToTeamByToken", "api.user.create_user.signup_link_invalid.app_error", nil, "", http.StatusBadRequest)
+		return nil, nil, model.NewAppError("AddUserToTeamByToken", "api.user.create_user.signup_link_invalid.app_error", nil, "", http.StatusBadRequest)
 	}
 
 	if model.GetMillis()-token.CreateAt >= InvitationExpiryTime {
 		a.DeleteToken(token)
-		return nil, model.NewAppError("AddUserToTeamByToken", "api.user.create_user.signup_link_expired.app_error", nil, "", http.StatusBadRequest)
+		return nil, nil, model.NewAppError("AddUserToTeamByToken", "api.user.create_user.signup_link_expired.app_error", nil, "", http.StatusBadRequest)
 	}
 
 	tokenData := model.MapFromJson(strings.NewReader(token.Extra))
@@ -577,15 +581,15 @@ func (a *App) AddUserToTeamByToken(userID string, tokenID string) (*model.Team,
 		var nfErr *store.ErrNotFound
 		switch {
 		case errors.As(result.NErr, &nfErr):
-			return nil, model.NewAppError("AddUserToTeamByToken", "app.team.get.find.app_error", nil, nfErr.Error(), http.StatusNotFound)
+			return nil, nil, model.NewAppError("AddUserToTeamByToken", "app.team.get.find.app_error", nil, nfErr.Error(), http.StatusNotFound)
 		default:
-			return nil, model.NewAppError("AddUserToTeamByToken", "app.team.get.finding.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
+			return nil, nil, model.NewAppError("AddUserToTeamByToken", "app.team.get.finding.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
 		}
 	}
 	team := result.Data.(*model.Team)
 
 	if team.IsGroupConstrained() {
-		return nil, model.NewAppError("AddUserToTeamByToken", "app.team.invite_token.group_constrained.error", nil, "", http.StatusForbidden)
+		return nil, nil, model.NewAppError("AddUserToTeamByToken", "app.team.invite_token.group_constrained.error", nil, "", http.StatusForbidden)
 	}
 
 	result = <-uchan
@@ -593,28 +597,29 @@ func (a *App) AddUserToTeamByToken(userID string, tokenID string) (*model.Team,
 		var nfErr *store.ErrNotFound
 		switch {
 		case errors.As(result.NErr, &nfErr):
-			return nil, model.NewAppError("AddUserToTeamByToken", MissingAccountError, nil, nfErr.Error(), http.StatusNotFound)
+			return nil, nil, model.NewAppError("AddUserToTeamByToken", MissingAccountError, nil, nfErr.Error(), http.StatusNotFound)
 		default:
-			return nil, model.NewAppError("AddUserToTeamByToken", "app.user.get.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
+			return nil, nil, model.NewAppError("AddUserToTeamByToken", "app.user.get.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
 		}
 	}
 	user := result.Data.(*model.User)
 
 	if user.IsGuest() && token.Type == TokenTypeTeamInvitation {
-		return nil, model.NewAppError("AddUserToTeamByToken", "api.user.create_user.invalid_invitation_type.app_error", nil, "", http.StatusBadRequest)
+		return nil, nil, model.NewAppError("AddUserToTeamByToken", "api.user.create_user.invalid_invitation_type.app_error", nil, "", http.StatusBadRequest)
 	}
 	if !user.IsGuest() && token.Type == TokenTypeGuestInvitation {
-		return nil, model.NewAppError("AddUserToTeamByToken", "api.user.create_user.invalid_invitation_type.app_error", nil, "", http.StatusBadRequest)
+		return nil, nil, model.NewAppError("AddUserToTeamByToken", "api.user.create_user.invalid_invitation_type.app_error", nil, "", http.StatusBadRequest)
 	}
 
-	if err := a.JoinUserToTeam(team, user, ""); err != nil {
+	teamMember, appErr := a.JoinUserToTeam(team, user, "")
-		return nil, err
+	if appErr != nil {
+		return nil, nil, appErr
 	}
 
 	if token.Type == TokenTypeGuestInvitation {
 		channels, err := a.Srv().Store.Channel().GetChannelsByIds(strings.Split(tokenData["channels"], " "), false)
 		if err != nil {
-			return nil, model.NewAppError("AddUserToTeamByToken", "app.channel.get_channels_by_ids.app_error", nil, err.Error(), http.StatusInternalServerError)
+			return nil, nil, model.NewAppError("AddUserToTeamByToken", "app.channel.get_channels_by_ids.app_error", nil, err.Error(), http.StatusInternalServerError)
 		}
 
 		for _, channel := range channels {
@@ -629,10 +634,10 @@ func (a *App) AddUserToTeamByToken(userID string, tokenID string) (*model.Team,
 		mlog.Warn("Error while deleting token", mlog.Err(err))
 	}
 
-	return team, nil
+	return team, teamMember, nil
 }
 
-func (a *App) AddUserToTeamByInviteId(inviteId string, userID string) (*model.Team, *model.AppError) {
+func (a *App) AddUserToTeamByInviteId(inviteId string, userID string) (*model.Team, *model.TeamMember, *model.AppError) {
 	tchan := make(chan store.StoreResult, 1)
 	go func() {
 		team, err := a.Srv().Store.Team().GetByInviteId(inviteId)
@@ -652,9 +657,9 @@ func (a *App) AddUserToTeamByInviteId(inviteId string, userID string) (*model.Te
 		var nfErr *store.ErrNotFound
 		switch {
 		case errors.As(result.NErr, &nfErr):
-			return nil, model.NewAppError("AddUserToTeamByInviteId", "app.team.get_by_invite_id.finding.app_error", nil, nfErr.Error(), http.StatusNotFound)
+			return nil, nil, model.NewAppError("AddUserToTeamByInviteId", "app.team.get_by_invite_id.finding.app_error", nil, nfErr.Error(), http.StatusNotFound)
 		default:
-			return nil, model.NewAppError("AddUserToTeamByInviteId", "app.team.get_by_invite_id.finding.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
+			return nil, nil, model.NewAppError("AddUserToTeamByInviteId", "app.team.get_by_invite_id.finding.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
 		}
 	}
 	team := result.Data.(*model.Team)
@@ -664,18 +669,19 @@ func (a *App) AddUserToTeamByInviteId(inviteId string, userID string) (*model.Te
 		var nfErr *store.ErrNotFound
 		switch {
 		case errors.As(result.NErr, &nfErr):
-			return nil, model.NewAppError("AddUserToTeamByInviteId", MissingAccountError, nil, nfErr.Error(), http.StatusNotFound)
+			return nil, nil, model.NewAppError("AddUserToTeamByInviteId", MissingAccountError, nil, nfErr.Error(), http.StatusNotFound)
 		default:
-			return nil, model.NewAppError("AddUserToTeamByInviteId", "app.user.get.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
+			return nil, nil, model.NewAppError("AddUserToTeamByInviteId", "app.user.get.app_error", nil, result.NErr.Error(), http.StatusInternalServerError)
 		}
 	}
 	user := result.Data.(*model.User)
 
-	if err := a.JoinUserToTeam(team, user, ""); err != nil {
+	teamMember, err := a.JoinUserToTeam(team, user, "")
-		return nil, err
+	if err != nil {
+		return nil, nil, err
 	}
 
-	return team, nil
+	return team, teamMember, nil
 }
 
 // Returns three values:
@@ -753,16 +759,16 @@ func (a *App) joinUserToTeam(team *model.Team, user *model.User) (*model.TeamMem
 	return member, false, nil
 }
 
-func (a *App) JoinUserToTeam(team *model.Team, user *model.User, userRequestorId string) *model.AppError {
+func (a *App) JoinUserToTeam(team *model.Team, user *model.User, userRequestorId string) (*model.TeamMember, *model.AppError) {
 	if !a.isTeamEmailAllowed(user, team) {
-		return model.NewAppError("JoinUserToTeam", "api.team.join_user_to_team.allowed_domains.app_error", nil, "", http.StatusBadRequest)
+		return nil, model.NewAppError("JoinUserToTeam", "api.team.join_user_to_team.allowed_domains.app_error", nil, "", http.StatusBadRequest)
 	}
-	tm, alreadyAdded, err := a.joinUserToTeam(team, user)
+	teamMember, alreadyAdded, err := a.joinUserToTeam(team, user)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	if alreadyAdded {
-		return nil
+		return teamMember, nil
 	}
 
 	if pluginsEnvironment := a.GetPluginsEnvironment(); pluginsEnvironment != nil {
@@ -774,14 +780,14 @@ func (a *App) JoinUserToTeam(team *model.Team, user *model.User, userRequestorId
 		a.Srv().Go(func() {
 			pluginContext := a.PluginContext()
 			pluginsEnvironment.RunMultiPluginHook(func(hooks plugin.Hooks) bool {
-				hooks.UserHasJoinedTeam(pluginContext, tm, actor)
+				hooks.UserHasJoinedTeam(pluginContext, teamMember, actor)
 				return true
 			}, plugin.UserHasJoinedTeamID)
 		})
 	}
 
 	if _, err := a.Srv().Store.User().UpdateUpdateAt(user.Id); err != nil {
-		return model.NewAppError("JoinUserToTeam", "app.user.update_update.app_error", nil, err.Error(), http.StatusInternalServerError)
+		return nil, model.NewAppError("JoinUserToTeam", "app.user.update_update.app_error", nil, err.Error(), http.StatusInternalServerError)
 	}
 
 	if _, err := a.createInitialSidebarCategories(user.Id, team.Id); err != nil {
@@ -816,7 +822,7 @@ func (a *App) JoinUserToTeam(team *model.Team, user *model.User, userRequestorId
 	message.Add("user_id", user.Id)
 	a.Publish(message)
 
-	return nil
+	return teamMember, nil
 }
 
 func (a *App) GetTeam(teamID string) (*model.Team, *model.AppError) {
@@ -1050,11 +1056,7 @@ func (a *App) GetTeamMembersByIds(teamID string, userIDs []string, restrictions
 }
 
 func (a *App) AddTeamMember(teamID, userID string) (*model.TeamMember, *model.AppError) {
-	if _, err := a.AddUserToTeam(teamID, userID, ""); err != nil {
+	_, teamMember, err := a.AddUserToTeam(teamID, userID, "")
-		return nil, err
-	}
-
-	teamMember, err := a.GetTeamMember(teamID, userID)
 	if err != nil {
 		return nil, err
 	}
@@ -1071,7 +1073,8 @@ func (a *App) AddTeamMembers(teamID string, userIDs []string, userRequestorId st
 	var membersWithErrors []*model.TeamMemberWithError
 
 	for _, userID := range userIDs {
-		if _, err := a.AddUserToTeam(teamID, userID, userRequestorId); err != nil {
+		_, teamMember, err := a.AddUserToTeam(teamID, userID, userRequestorId)
+		if err != nil {
 			if graceful {
 				membersWithErrors = append(membersWithErrors, &model.TeamMemberWithError{
 					UserId: userID,
@@ -1082,10 +1085,6 @@ func (a *App) AddTeamMembers(teamID string, userIDs []string, userRequestorId st
 			return nil, err
 		}
 
-		teamMember, err := a.GetTeamMember(teamID, userID)
-		if err != nil {
-			return nil, err
-		}
 		membersWithErrors = append(membersWithErrors, &model.TeamMemberWithError{
 			UserId: userID,
 			Member: teamMember,
@@ -1101,12 +1100,7 @@ func (a *App) AddTeamMembers(teamID string, userIDs []string, userRequestorId st
 }
 
 func (a *App) AddTeamMemberByToken(userID, tokenID string) (*model.TeamMember, *model.AppError) {
-	team, err := a.AddUserToTeamByToken(userID, tokenID)
+	_, teamMember, err := a.AddUserToTeamByToken(userID, tokenID)
-	if err != nil {
-		return nil, err
-	}
-
-	teamMember, err := a.GetTeamMember(team.Id, userID)
 	if err != nil {
 		return nil, err
 	}
@@ -1115,7 +1109,7 @@ func (a *App) AddTeamMemberByToken(userID, tokenID string) (*model.TeamMember, *
 }
 
 func (a *App) AddTeamMemberByInviteId(inviteId, userID string) (*model.TeamMember, *model.AppError) {
-	team, err := a.AddUserToTeamByInviteId(inviteId, userID)
+	team, teamMember, err := a.AddUserToTeamByInviteId(inviteId, userID)
 	if err != nil {
 		return nil, err
 	}
@@ -1124,10 +1118,6 @@ func (a *App) AddTeamMemberByInviteId(inviteId, userID string) (*model.TeamMembe
 		return nil, model.NewAppError("AddTeamMemberByInviteId", "app.team.invite_id.group_constrained.error", nil, "", http.StatusForbidden)
 	}
 
-	teamMember, err := a.GetTeamMember(team.Id, userID)
-	if err != nil {
-		return nil, err
-	}
 	return teamMember, nil
 }
 

app/team_test.go

@@ -76,7 +76,7 @@ func TestAddUserToTeam(t *testing.T) {
 		ruser, _ := th.App.CreateUser(&user)
 		defer th.App.PermanentDeleteUser(&user)
 
-		_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.Nil(t, err, "Should add user to the team")
 	})
 
@@ -89,7 +89,7 @@ func TestAddUserToTeam(t *testing.T) {
 		ruser, _ := th.App.CreateUser(&user)
 		defer th.App.PermanentDeleteUser(&user)
 
-		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.Nil(t, err, "Should have allowed whitelisted user")
 	})
 
@@ -103,7 +103,7 @@ func TestAddUserToTeam(t *testing.T) {
 		require.Nil(t, err, "Error creating user: %s", err)
 		defer th.App.PermanentDeleteUser(&user)
 
-		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.NotNil(t, err, "Should not add restricted user")
 		require.Equal(t, "JoinUserToTeam", err.Where, "Error should be JoinUserToTeam")
 
@@ -112,7 +112,7 @@ func TestAddUserToTeam(t *testing.T) {
 		require.Nil(t, err, "Error creating authservice user: %s", err)
 		defer th.App.PermanentDeleteUser(&user)
 
-		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.NotNil(t, err, "Should not add authservice user")
 		require.Equal(t, "JoinUserToTeam", err.Where, "Error should be JoinUserToTeam")
 
@@ -123,7 +123,7 @@ func TestAddUserToTeam(t *testing.T) {
 		})
 		require.Nil(t, err)
 
-		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, bot.UserId, "")
+		_, _, err = th.App.AddUserToTeam(th.BasicTeam.Id, bot.UserId, "")
 		assert.Nil(t, err, "should be able to add bot to domain restricted team")
 	})
 
@@ -136,7 +136,7 @@ func TestAddUserToTeam(t *testing.T) {
 		ruser, _ := th.App.CreateUser(&user)
 		defer th.App.PermanentDeleteUser(&user)
 
-		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.NotNil(t, err, "Should not add restricted user")
 		require.Equal(t, "JoinUserToTeam", err.Where, "Error should be JoinUserToTeam")
 	})
@@ -159,13 +159,13 @@ func TestAddUserToTeam(t *testing.T) {
 		defer th.App.PermanentDeleteUser(&user2)
 		defer th.App.PermanentDeleteUser(&user3)
 
-		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser1.Id, "")
+		_, _, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser1.Id, "")
 		require.Nil(t, err, "Should have allowed whitelisted user1")
 
-		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser2.Id, "")
+		_, _, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser2.Id, "")
 		require.Nil(t, err, "Should have allowed whitelisted user2")
 
-		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser3.Id, "")
+		_, _, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser3.Id, "")
 		require.NotNil(t, err, "Should not have allowed restricted user3")
 		require.Equal(t, "JoinUserToTeam", err.Where, "Error should be JoinUserToTeam")
 	})
@@ -174,7 +174,7 @@ func TestAddUserToTeam(t *testing.T) {
 		user := th.CreateUser()
 		team := th.CreateTeam()
 
-		_, err := th.App.AddUserToTeam(team.Id, user.Id, "")
+		_, _, err := th.App.AddUserToTeam(team.Id, user.Id, "")
 		require.Nil(t, err)
 
 		res, err := th.App.GetSidebarCategories(user.Id, team.Id)
@@ -195,7 +195,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 	rguest := th.CreateGuest()
 
 	t.Run("invalid token", func(t *testing.T) {
-		_, err := th.App.AddUserToTeamByToken(ruser.Id, "123")
+		_, _, err := th.App.AddUserToTeamByToken(ruser.Id, "123")
 		require.NotNil(t, err, "Should fail on unexisting token")
 	})
 
@@ -208,7 +208,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		defer th.App.DeleteToken(token)
 
-		_, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
+		_, _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
 		require.NotNil(t, err, "Should fail on bad token type")
 	})
 
@@ -222,7 +222,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		defer th.App.DeleteToken(token)
 
-		_, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
+		_, _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
 		require.NotNil(t, err, "Should fail on expired token")
 	})
 
@@ -234,7 +234,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		defer th.App.DeleteToken(token)
 
-		_, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
+		_, _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
 		require.NotNil(t, err, "Should fail on bad team id")
 	})
 
@@ -246,7 +246,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 		defer th.App.DeleteToken(token)
 
-		_, err := th.App.AddUserToTeamByToken(model.NewId(), token.Token)
+		_, _, err := th.App.AddUserToTeamByToken(model.NewId(), token.Token)
 		require.NotNil(t, err, "Should fail on bad user id")
 	})
 
@@ -256,7 +256,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}),
 		)
 		require.NoError(t, th.App.Srv().Store.Token().Save(token))
-		_, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
+		_, _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
 		require.Nil(t, err, "Should add user to the team")
 
 		_, nErr := th.App.Srv().Store.Token().GetByToken(token.Token)
@@ -273,7 +273,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id}),
 		)
 		require.NoError(t, th.App.Srv().Store.Token().Save(token))
-		_, err := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
+		_, _, err := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
 		assert.NotNil(t, err)
 	})
 
@@ -283,7 +283,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id, "channels": th.BasicChannel.Id}),
 		)
 		require.NoError(t, th.App.Srv().Store.Token().Save(token))
-		_, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
+		_, _, err := th.App.AddUserToTeamByToken(ruser.Id, token.Token)
 		assert.NotNil(t, err)
 	})
 
@@ -298,7 +298,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 			model.MapToJson(map[string]string{"teamId": th.BasicTeam.Id, "channels": th.BasicChannel.Id}),
 		)
 		require.NoError(t, th.App.Srv().Store.Token().Save(token))
-		_, err := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
+		_, _, err := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
 		require.NotNil(t, err)
 		assert.Equal(t, "api.team.join_user_to_team.allowed_domains.app_error", err.Id)
 	})
@@ -319,7 +319,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 		th.App.InvalidateCacheForUser(rguest.Id)
 		require.NoError(t, err)
 		require.NoError(t, th.App.Srv().Store.Token().Save(token))
-		_, appErr := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
+		_, _, appErr := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
 		require.Nil(t, appErr)
 		rguest.Email = guestEmail
 		_, err = th.App.Srv().Store.User().Update(rguest, false)
@@ -342,7 +342,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 		_, err = th.App.Srv().Store.User().Update(rguest, false)
 		require.NoError(t, err)
 		require.NoError(t, th.App.Srv().Store.Token().Save(token))
-		_, appErr := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
+		_, _, appErr := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
 		require.Nil(t, appErr)
 		th.BasicTeam.AllowedDomains = ""
 		_, err = th.Server.Store.Team().Update(th.BasicTeam)
@@ -356,7 +356,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 		)
 		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 
-		_, err := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
+		_, _, err := th.App.AddUserToTeamByToken(rguest.Id, token.Token)
 		require.Nil(t, err, "Should add user to the team")
 
 		_, nErr := th.App.Srv().Store.Token().GetByToken(token.Token)
@@ -379,7 +379,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 		)
 		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 
-		_, err = th.App.AddUserToTeamByToken(ruser.Id, token.Token)
+		_, _, err = th.App.AddUserToTeamByToken(ruser.Id, token.Token)
 		require.NotNil(t, err, "Should return an error when trying to join a group-constrained team.")
 		require.Equal(t, "app.team.invite_token.group_constrained.error", err.Id)
 
@@ -403,7 +403,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 		)
 		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 
-		_, err = th.App.AddUserToTeamByToken(ruser.Id, token.Token)
+		_, _, err = th.App.AddUserToTeamByToken(ruser.Id, token.Token)
 		require.NotNil(t, err, "Should not add restricted user")
 		require.Equal(t, "JoinUserToTeam", err.Where, "Error should be JoinUserToTeam")
 	})
@@ -418,7 +418,7 @@ func TestAddUserToTeamByToken(t *testing.T) {
 		)
 		require.NoError(t, th.App.Srv().Store.Token().Save(token))
 
-		_, err := th.App.AddUserToTeamByToken(user.Id, token.Token)
+		_, _, err := th.App.AddUserToTeamByToken(user.Id, token.Token)
 		require.Nil(t, err)
 
 		res, err := th.App.GetSidebarCategories(user.Id, team.Id)
@@ -880,7 +880,7 @@ func TestGetTeamMembers(t *testing.T) {
 		require.NotNil(t, ruser)
 		defer th.App.PermanentDeleteUser(&user)
 
-		_, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err = th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.Nil(t, err)
 
 		// Store the users for comparison later
@@ -1041,7 +1041,7 @@ func TestUpdateTeamMemberRolesChangingGuest(t *testing.T) {
 		user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
 		ruser, _ := th.App.CreateGuest(&user)
 
-		_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.Nil(t, err)
 
 		_, err = th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_user")
@@ -1052,7 +1052,7 @@ func TestUpdateTeamMemberRolesChangingGuest(t *testing.T) {
 		user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
 		ruser, _ := th.App.CreateUser(&user)
 
-		_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.Nil(t, err)
 
 		_, err = th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_guest")
@@ -1063,7 +1063,7 @@ func TestUpdateTeamMemberRolesChangingGuest(t *testing.T) {
 		user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
 		ruser, _ := th.App.CreateUser(&user)
 
-		_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.Nil(t, err)
 
 		_, err = th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_user team_admin")
@@ -1074,7 +1074,7 @@ func TestUpdateTeamMemberRolesChangingGuest(t *testing.T) {
 		user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
 		ruser, _ := th.App.CreateGuest(&user)
 
-		_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.Nil(t, err)
 
 		_, err = th.App.CreateRole(&model.Role{Name: "custom", DisplayName: "custom", Description: "custom"})
@@ -1088,7 +1088,7 @@ func TestUpdateTeamMemberRolesChangingGuest(t *testing.T) {
 		user := model.User{Email: strings.ToLower(model.NewId()) + "success+test@example.com", Nickname: "Darth Vader", Username: "vader" + model.NewId(), Password: "passwd1", AuthService: ""}
 		ruser, _ := th.App.CreateGuest(&user)
 
-		_, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
+		_, _, err := th.App.AddUserToTeam(th.BasicTeam.Id, ruser.Id, "")
 		require.Nil(t, err)
 
 		_, err = th.App.UpdateTeamMemberRoles(th.BasicTeam.Id, ruser.Id, "team_guest team_user")

app/user.go

@@ -96,7 +96,7 @@ func (a *App) CreateUserWithToken(user *model.User, token *model.Token) (*model.
 		return nil, err
 	}
 
-	if err := a.JoinUserToTeam(team, ruser, ""); err != nil {
+	if _, err := a.JoinUserToTeam(team, ruser, ""); err != nil {
 		return nil, err
 	}
 
@@ -149,7 +149,7 @@ func (a *App) CreateUserWithInviteId(user *model.User, inviteId, redirect string
 		return nil, err
 	}
 
-	if err := a.JoinUserToTeam(team, ruser, ""); err != nil {
+	if _, err := a.JoinUserToTeam(team, ruser, ""); err != nil {
 		return nil, err
 	}
 

cmd/mattermost/commands/team.go

@@ -243,7 +243,7 @@ func addUserToTeam(a *app.App, team *model.Team, user *model.User, userArg strin
 		CommandPrintErrorln("Can't find user '" + userArg + "'")
 		return
 	}
-	if err := a.JoinUserToTeam(team, user, ""); err != nil {
+	if _, err := a.JoinUserToTeam(team, user, ""); err != nil {
 		CommandPrintErrorln("Unable to add '" + userArg + "' to " + team.Name)
 		return
 	}

migrations/helper_test.go

@@ -206,7 +206,7 @@ func (th *TestHelper) CreatePost(channel *model.Channel) *model.Post {
 func (th *TestHelper) LinkUserToTeam(user *model.User, team *model.Team) {
 	utils.DisableDebugLogForTest()
 
-	err := th.App.JoinUserToTeam(team, user, "")
+	_, err := th.App.JoinUserToTeam(team, user, "")
 	if err != nil {
 		panic(err)
 	}

services/slackimport/slackimport.go

@@ -84,7 +84,7 @@ type slackComment struct {
 type Actions struct {
 	UpdateActive           func(*model.User, bool) (*model.User, *model.AppError)
 	AddUserToChannel       func(*model.User, *model.Channel) (*model.ChannelMember, *model.AppError)
-	JoinUserToTeam         func(*model.Team, *model.User, string) *model.AppError
+	JoinUserToTeam         func(*model.Team, *model.User, string) (*model.TeamMember, *model.AppError)
 	CreateDirectChannel    func(string, string, ...model.ChannelOption) (*model.Channel, *model.AppError)
 	CreateGroupChannel     func([]string) (*model.Channel, *model.AppError)
 	CreateChannel          func(*model.Channel, bool) (*model.Channel, *model.AppError)
@@ -234,7 +234,7 @@ func (si *SlackImporter) slackAddUsers(teamId string, slackusers []slackUser, im
 		// Check for email conflict and use existing user if found
 		if existingUser, err := si.store.User().GetByEmail(email); err == nil {
 			addedUsers[sUser.Id] = existingUser
-			if err := si.actions.JoinUserToTeam(team, addedUsers[sUser.Id], ""); err != nil {
+			if _, err := si.actions.JoinUserToTeam(team, addedUsers[sUser.Id], ""); err != nil {
 				importerLog.WriteString(i18n.T("api.slackimport.slack_add_users.merge_existing_failed", map[string]interface{}{"Email": existingUser.Email, "Username": existingUser.Username}))
 			} else {
 				importerLog.WriteString(i18n.T("api.slackimport.slack_add_users.merge_existing", map[string]interface{}{"Email": existingUser.Email, "Username": existingUser.Username}))
@@ -695,7 +695,7 @@ func (si *SlackImporter) oldImportUser(team *model.Team, user *model.User) *mode
 		mlog.Warn("Failed to set email verified.", mlog.Err(err))
 	}
 
-	if err := si.actions.JoinUserToTeam(team, user, ""); err != nil {
+	if _, err := si.actions.JoinUserToTeam(team, user, ""); err != nil {
 		mlog.Warn("Failed to join team when importing.", mlog.Err(err))
 	}