MM-43084 update product limits through webhook and websocket (#20076)

* Define interfaces for updating subscriptions and product limits from CWS webhook.

plugin/api.go

@@ -1147,6 +1147,11 @@ type API interface {
 	//
 	// Minimum server version: 5.36
 	RequestTrialLicense(requesterID string, users int, termsAccepted bool, receiveEmailsAccepted bool) *model.AppError
+
+	// GetCloudLimits gets limits associated with a cloud workspace, if any
+	//
+	// Minimum server version: 7.0
+	GetCloudLimits() (*model.ProductLimits, error)
 }
 
 var handshake = plugin.HandshakeConfig{

plugin/api_timer_layer_generated.go

@@ -1225,3 +1225,10 @@ func (api *apiTimerLayer) RequestTrialLicense(requesterID string, users int, ter
 	api.recordTime(startTime, "RequestTrialLicense", _returnsA == nil)
 	return _returnsA
 }
+
+func (api *apiTimerLayer) GetCloudLimits() (*model.ProductLimits, error) {
+	startTime := timePkg.Now()
+	_returnsA, _returnsB := api.apiImpl.GetCloudLimits()
+	api.recordTime(startTime, "GetCloudLimits", _returnsB == nil)
+	return _returnsA, _returnsB
+}

plugin/client_rpc_generated.go

@@ -774,6 +774,39 @@ func (s *hooksRPCServer) OnSendDailyTelemetry(args *Z_OnSendDailyTelemetryArgs,
 	return nil
 }
 
+func init() {
+	hookNameToId["OnCloudLimitsUpdated"] = OnCloudLimitsUpdatedID
+}
+
+type Z_OnCloudLimitsUpdatedArgs struct {
+	A *model.ProductLimits
+}
+
+type Z_OnCloudLimitsUpdatedReturns struct {
+}
+
+func (g *hooksRPCClient) OnCloudLimitsUpdated(limits *model.ProductLimits) {
+	_args := &Z_OnCloudLimitsUpdatedArgs{limits}
+	_returns := &Z_OnCloudLimitsUpdatedReturns{}
+	if g.implemented[OnCloudLimitsUpdatedID] {
+		if err := g.client.Call("Plugin.OnCloudLimitsUpdated", _args, _returns); err != nil {
+			g.log.Error("RPC call OnCloudLimitsUpdated to plugin failed.", mlog.Err(err))
+		}
+	}
+
+}
+
+func (s *hooksRPCServer) OnCloudLimitsUpdated(args *Z_OnCloudLimitsUpdatedArgs, returns *Z_OnCloudLimitsUpdatedReturns) error {
+	if hook, ok := s.impl.(interface {
+		OnCloudLimitsUpdated(limits *model.ProductLimits)
+	}); ok {
+		hook.OnCloudLimitsUpdated(args.A)
+	} else {
+		return encodableError(fmt.Errorf("Hook OnCloudLimitsUpdated called but not implemented."))
+	}
+	return nil
+}
+
 type Z_RegisterCommandArgs struct {
 	A *model.Command
 }
@@ -5616,3 +5649,32 @@ func (s *apiRPCServer) RequestTrialLicense(args *Z_RequestTrialLicenseArgs, retu
 	}
 	return nil
 }
+
+type Z_GetCloudLimitsArgs struct {
+}
+
+type Z_GetCloudLimitsReturns struct {
+	A *model.ProductLimits
+	B error
+}
+
+func (g *apiRPCClient) GetCloudLimits() (*model.ProductLimits, error) {
+	_args := &Z_GetCloudLimitsArgs{}
+	_returns := &Z_GetCloudLimitsReturns{}
+	if err := g.client.Call("Plugin.GetCloudLimits", _args, _returns); err != nil {
+		log.Printf("RPC call to GetCloudLimits API failed: %s", err.Error())
+	}
+	return _returns.A, _returns.B
+}
+
+func (s *apiRPCServer) GetCloudLimits(args *Z_GetCloudLimitsArgs, returns *Z_GetCloudLimitsReturns) error {
+	if hook, ok := s.impl.(interface {
+		GetCloudLimits() (*model.ProductLimits, error)
+	}); ok {
+		returns.A, returns.B = hook.GetCloudLimits()
+		returns.B = encodableError(returns.B)
+	} else {
+		return encodableError(fmt.Errorf("API GetCloudLimits called but not implemented."))
+	}
+	return nil
+}

plugin/hooks.go

@@ -42,6 +42,7 @@ const (
 	RunDataRetentionID              = 24
 	OnInstallID                     = 25
 	OnSendDailyTelemetryID          = 26
+	OnCloudLimitsUpdatedID          = 27
 	TotalHooksID                    = iota
 )
 
@@ -264,4 +265,9 @@ type Hooks interface {
 	//
 	// Minimum server version: 6.5
 	OnSendDailyTelemetry()
+
+	// OnCloudLimitsUpdated is invoked product limits change, for example when plan tiers change
+	//
+	// Minimum server version: 7.0
+	OnCloudLimitsUpdated(limits *model.ProductLimits)
 }

plugin/hooks_timer_layer_generated.go

@@ -206,3 +206,9 @@ func (hooks *hooksTimerLayer) OnSendDailyTelemetry() {
 	hooks.hooksImpl.OnSendDailyTelemetry()
 	hooks.recordTime(startTime, "OnSendDailyTelemetry", true)
 }
+
+func (hooks *hooksTimerLayer) OnCloudLimitsUpdated(limits *model.ProductLimits) {
+	startTime := timePkg.Now()
+	hooks.hooksImpl.OnCloudLimitsUpdated(limits)
+	hooks.recordTime(startTime, "OnCloudLimitsUpdated", true)
+}

plugin/plugintest/api.go

@@ -980,6 +980,29 @@ func (_m *API) GetChannelsForTeamForUser(teamID string, userID string, includeDe
 	return r0, r1
 }
 
+// GetCloudLimits provides a mock function with given fields:
+func (_m *API) GetCloudLimits() (*model.ProductLimits, error) {
+	ret := _m.Called()
+
+	var r0 *model.ProductLimits
+	if rf, ok := ret.Get(0).(func() *model.ProductLimits); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ProductLimits)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
 // GetCommand provides a mock function with given fields: commandID
 func (_m *API) GetCommand(commandID string) (*model.Command, error) {
 	ret := _m.Called(commandID)

plugin/plugintest/hooks.go

@@ -166,6 +166,11 @@ func (_m *Hooks) OnActivate() error {
 	return r0
 }
 
+// OnCloudLimitsUpdated provides a mock function with given fields: limits
+func (_m *Hooks) OnCloudLimitsUpdated(limits *model.ProductLimits) {
+	_m.Called(limits)
+}
+
 // OnConfigurationChange provides a mock function with given fields:
 func (_m *Hooks) OnConfigurationChange() error {
 	ret := _m.Called()