Added API to return user count bands and user count (#25796)

server/channels/app/app_iface.go

@@ -826,6 +826,7 @@ type AppIface interface {
 	GetUserByRemoteID(remoteID string) (*model.User, *model.AppError)
 	GetUserByUsername(username string) (*model.User, *model.AppError)
 	GetUserForLogin(c request.CTX, id, loginId string) (*model.User, *model.AppError)
+	GetUserLimits() (*model.UserLimits, *model.AppError)
 	GetUserTermsOfService(userID string) (*model.UserTermsOfService, *model.AppError)
 	GetUsers(userIDs []string) ([]*model.User, *model.AppError)
 	GetUsersByGroupChannelIds(c request.CTX, channelIDs []string, asAdmin bool) (map[string][]*model.User, *model.AppError)

server/channels/app/limits.go

@@ -0,0 +1,42 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package app
+
+import (
+	"net/http"
+
+	"github.com/mattermost/mattermost/server/public/model"
+)
+
+const (
+	lowerBandUsersLimit = 500
+	upperBandUsersLimit = 9000
+	maxUsersLimit       = 10000
+)
+
+func (a *App) GetUserLimits() (*model.UserLimits, *model.AppError) {
+	if !a.shouldShowUserLimits() {
+		return &model.UserLimits{}, nil
+	}
+
+	activeUserCount, appErr := a.Srv().Store().User().Count(model.UserCountOptions{})
+	if appErr != nil {
+		return nil, model.NewAppError("GetUsersLimits", "app.limits.get_user_limits.user_count.store_error", nil, "", http.StatusInternalServerError).Wrap(appErr)
+	}
+
+	return &model.UserLimits{
+		ActiveUserCount:    activeUserCount,
+		LowerBandUserLimit: lowerBandUsersLimit,
+		UpperBandUserLimit: upperBandUsersLimit,
+		MaxUsersLimit:      maxUsersLimit,
+	}, nil
+}
+
+func (a *App) shouldShowUserLimits() bool {
+	if maxUsersLimit == 0 {
+		return false
+	}
+
+	return a.License() == nil
+}

server/channels/app/limits_test.go

@@ -0,0 +1,136 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package app
+
+import (
+	"testing"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGetUserLimits(t *testing.T) {
+	th := Setup(t).InitBasic()
+	defer th.TearDown()
+
+	t.Run("base case", func(t *testing.T) {
+		userLimits, appErr := th.App.GetUserLimits()
+		require.Nil(t, appErr)
+
+		// InitBasic creates 3 users by default
+		require.Equal(t, int64(3), userLimits.ActiveUserCount)
+		require.Equal(t, int64(10000), userLimits.MaxUsersLimit)
+		require.Equal(t, int64(500), userLimits.LowerBandUserLimit)
+		require.Equal(t, int64(9000), userLimits.UpperBandUserLimit)
+	})
+
+	t.Run("user count should increase on creating new user and decrease on permanently deleting", func(t *testing.T) {
+		userLimits, appErr := th.App.GetUserLimits()
+		require.Nil(t, appErr)
+		require.Equal(t, int64(3), userLimits.ActiveUserCount)
+
+		// now we create a new user
+		newUser := th.CreateUser()
+
+		userLimits, appErr = th.App.GetUserLimits()
+		require.Nil(t, appErr)
+		require.Equal(t, int64(4), userLimits.ActiveUserCount)
+
+		// now we'll delete the user
+		_ = th.App.PermanentDeleteUser(th.Context, newUser)
+		userLimits, appErr = th.App.GetUserLimits()
+		require.Nil(t, appErr)
+		require.Equal(t, int64(3), userLimits.ActiveUserCount)
+	})
+
+	t.Run("user count should increase on creating new guest user and decrease on permanently deleting", func(t *testing.T) {
+		userLimits, appErr := th.App.GetUserLimits()
+		require.Nil(t, appErr)
+		require.Equal(t, int64(3), userLimits.ActiveUserCount)
+
+		// now we create a new user
+		newGuestUser := th.CreateGuest()
+
+		userLimits, appErr = th.App.GetUserLimits()
+		require.Nil(t, appErr)
+		require.Equal(t, int64(4), userLimits.ActiveUserCount)
+
+		// now we'll delete the user
+		_ = th.App.PermanentDeleteUser(th.Context, newGuestUser)
+		userLimits, appErr = th.App.GetUserLimits()
+		require.Nil(t, appErr)
+		require.Equal(t, int64(3), userLimits.ActiveUserCount)
+	})
+
+	t.Run("user count should increase on creating new user and decrease on soft deleting", func(t *testing.T) {
+		userLimits, appErr := th.App.GetUserLimits()
+		require.Nil(t, appErr)
+		require.Equal(t, int64(3), userLimits.ActiveUserCount)
+
+		// now we create a new user
+		newUser := th.CreateUser()
+
+		userLimits, appErr = th.App.GetUserLimits()
+		require.Nil(t, appErr)
+		require.Equal(t, int64(4), userLimits.ActiveUserCount)
+
+		// now we'll delete the user
+		_, appErr = th.App.UpdateActive(th.Context, newUser, false)
+		require.Nil(t, appErr)
+		userLimits, appErr = th.App.GetUserLimits()
+		require.Nil(t, appErr)
+		require.Equal(t, int64(3), userLimits.ActiveUserCount)
+	})
+
+	t.Run("user count should increase on creating new guest user and decrease on soft deleting", func(t *testing.T) {
+		userLimits, appErr := th.App.GetUserLimits()
+		require.Nil(t, appErr)
+		require.Equal(t, int64(3), userLimits.ActiveUserCount)
+
+		// now we create a new user
+		newGuestUser := th.CreateGuest()
+
+		userLimits, appErr = th.App.GetUserLimits()
+		require.Nil(t, appErr)
+		require.Equal(t, int64(4), userLimits.ActiveUserCount)
+
+		// now we'll delete the user
+		_, appErr = th.App.UpdateActive(th.Context, newGuestUser, false)
+		require.Nil(t, appErr)
+		userLimits, appErr = th.App.GetUserLimits()
+		require.Nil(t, appErr)
+		require.Equal(t, int64(3), userLimits.ActiveUserCount)
+	})
+
+	t.Run("user count should not change on creating or deleting bots", func(t *testing.T) {
+		userLimits, appErr := th.App.GetUserLimits()
+		require.Nil(t, appErr)
+		require.Equal(t, int64(3), userLimits.ActiveUserCount)
+
+		// now we create a new bot
+		newBot := th.CreateBot()
+
+		userLimits, appErr = th.App.GetUserLimits()
+		require.Nil(t, appErr)
+		require.Equal(t, int64(3), userLimits.ActiveUserCount)
+
+		// now we'll delete the bot
+		_ = th.App.PermanentDeleteBot(newBot.UserId)
+		userLimits, appErr = th.App.GetUserLimits()
+		require.Nil(t, appErr)
+		require.Equal(t, int64(3), userLimits.ActiveUserCount)
+	})
+
+	t.Run("limits should be empty when there is a license", func(t *testing.T) {
+		th.App.Srv().SetLicense(model.NewTestLicense())
+
+		userLimits, appErr := th.App.GetUserLimits()
+		require.Nil(t, appErr)
+
+		require.Equal(t, int64(0), userLimits.ActiveUserCount)
+		require.Equal(t, int64(0), userLimits.MaxUsersLimit)
+		require.Equal(t, int64(0), userLimits.LowerBandUserLimit)
+		require.Equal(t, int64(0), userLimits.UpperBandUserLimit)
+	})
+}

server/channels/app/opentracing/opentracing_layer.go

@@ -10555,6 +10555,28 @@ func (a *OpenTracingAppLayer) GetUserForLogin(c request.CTX, id string, loginId
 	return resultVar0, resultVar1
 }
 
+func (a *OpenTracingAppLayer) GetUserLimits() (*model.UserLimits, *model.AppError) {
+	origCtx := a.ctx
+	span, newCtx := tracing.StartSpanWithParentByContext(a.ctx, "app.GetUserLimits")
+
+	a.ctx = newCtx
+	a.app.Srv().Store().SetContext(newCtx)
+	defer func() {
+		a.app.Srv().Store().SetContext(origCtx)
+		a.ctx = origCtx
+	}()
+
+	defer span.Finish()
+	resultVar0, resultVar1 := a.app.GetUserLimits()
+
+	if resultVar1 != nil {
+		span.LogFields(spanlog.Error(resultVar1))
+		ext.Error.Set(span, true)
+	}
+
+	return resultVar0, resultVar1
+}
+
 func (a *OpenTracingAppLayer) GetUserStatusesByIds(userIDs []string) ([]*model.Status, *model.AppError) {
 	origCtx := a.ctx
 	span, newCtx := tracing.StartSpanWithParentByContext(a.ctx, "app.GetUserStatusesByIds")