Mono repo -> Master (#22553)

Combines the following repositories into one:

https://github.com/mattermost/mattermost-server
https://github.com/mattermost/mattermost-webapp
https://github.com/mattermost/focalboard
https://github.com/mattermost/mattermost-plugin-playbooks

server/boards/product/api_adapter.go

@@ -0,0 +1,257 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package product
+
+import (
+	"database/sql"
+
+	"github.com/gorilla/mux"
+
+	mm_model "github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/app/request"
+	"github.com/mattermost/mattermost-server/v6/server/platform/shared/mlog"
+
+	"github.com/mattermost/mattermost-server/v6/server/boards/model"
+)
+
+// normalizeAppError returns a truly nil error if appErr is nil
+// See https://golang.org/doc/faq#nil_error for more details.
+func normalizeAppErr(appErr *mm_model.AppError) error {
+	if appErr == nil {
+		return nil
+	}
+	return appErr
+}
+
+// serviceAPIAdapter is an adapter that flattens the APIs provided by suite services so they can
+// be used as per the Plugin API.
+// Note: when supporting a plugin build is no longer needed this adapter may be removed as the Boards app
+// can be modified to use the services in modular fashion.
+type serviceAPIAdapter struct {
+	api *boardsProduct
+	ctx *request.Context
+}
+
+func newServiceAPIAdapter(api *boardsProduct) *serviceAPIAdapter {
+	return &serviceAPIAdapter{
+		api: api,
+		ctx: request.EmptyContext(api.logger),
+	}
+}
+
+//
+// Channels service.
+//
+
+func (a *serviceAPIAdapter) GetDirectChannel(userID1, userID2 string) (*mm_model.Channel, error) {
+	channel, appErr := a.api.channelService.GetDirectChannel(userID1, userID2)
+	return channel, normalizeAppErr(appErr)
+}
+
+func (a *serviceAPIAdapter) GetDirectChannelOrCreate(userID1, userID2 string) (*mm_model.Channel, error) {
+	channel, appErr := a.api.channelService.GetDirectChannelOrCreate(userID1, userID2)
+	return channel, normalizeAppErr(appErr)
+}
+
+func (a *serviceAPIAdapter) GetChannelByID(channelID string) (*mm_model.Channel, error) {
+	channel, appErr := a.api.channelService.GetChannelByID(channelID)
+	return channel, normalizeAppErr(appErr)
+}
+
+func (a *serviceAPIAdapter) GetChannelMember(channelID string, userID string) (*mm_model.ChannelMember, error) {
+	member, appErr := a.api.channelService.GetChannelMember(channelID, userID)
+	return member, normalizeAppErr(appErr)
+}
+
+func (a *serviceAPIAdapter) GetChannelsForTeamForUser(teamID string, userID string, includeDeleted bool) (mm_model.ChannelList, error) {
+	opts := &mm_model.ChannelSearchOpts{
+		IncludeDeleted: includeDeleted,
+	}
+	channels, appErr := a.api.channelService.GetChannelsForTeamForUser(teamID, userID, opts)
+	return channels, normalizeAppErr(appErr)
+}
+
+//
+// Post service.
+//
+
+func (a *serviceAPIAdapter) CreatePost(post *mm_model.Post) (*mm_model.Post, error) {
+	post, appErr := a.api.postService.CreatePost(a.ctx, post)
+	return post, normalizeAppErr(appErr)
+}
+
+//
+// User service.
+//
+
+func (a *serviceAPIAdapter) GetUserByID(userID string) (*mm_model.User, error) {
+	user, appErr := a.api.userService.GetUser(userID)
+	return user, normalizeAppErr(appErr)
+}
+
+func (a *serviceAPIAdapter) GetUserByUsername(name string) (*mm_model.User, error) {
+	user, appErr := a.api.userService.GetUserByUsername(name)
+	return user, normalizeAppErr(appErr)
+}
+
+func (a *serviceAPIAdapter) GetUserByEmail(email string) (*mm_model.User, error) {
+	user, appErr := a.api.userService.GetUserByEmail(email)
+	return user, normalizeAppErr(appErr)
+}
+
+func (a *serviceAPIAdapter) UpdateUser(user *mm_model.User) (*mm_model.User, error) {
+	user, appErr := a.api.userService.UpdateUser(a.ctx, user, true)
+	return user, normalizeAppErr(appErr)
+}
+
+func (a *serviceAPIAdapter) GetUsersFromProfiles(options *mm_model.UserGetOptions) ([]*mm_model.User, error) {
+	user, appErr := a.api.userService.GetUsersFromProfiles(options)
+	return user, normalizeAppErr(appErr)
+}
+
+//
+// Team service.
+//
+
+func (a *serviceAPIAdapter) GetTeamMember(teamID string, userID string) (*mm_model.TeamMember, error) {
+	member, appErr := a.api.teamService.GetMember(teamID, userID)
+	return member, normalizeAppErr(appErr)
+}
+
+func (a *serviceAPIAdapter) CreateMember(teamID string, userID string) (*mm_model.TeamMember, error) {
+	member, appErr := a.api.teamService.CreateMember(a.ctx, teamID, userID)
+	return member, normalizeAppErr(appErr)
+}
+
+//
+// Permissions service.
+//
+
+func (a *serviceAPIAdapter) HasPermissionTo(userID string, permission *mm_model.Permission) bool {
+	return a.api.permissionsService.HasPermissionTo(userID, permission)
+}
+
+func (a *serviceAPIAdapter) HasPermissionToTeam(userID, teamID string, permission *mm_model.Permission) bool {
+	return a.api.permissionsService.HasPermissionToTeam(userID, teamID, permission)
+}
+
+func (a *serviceAPIAdapter) HasPermissionToChannel(askingUserID string, channelID string, permission *mm_model.Permission) bool {
+	return a.api.permissionsService.HasPermissionToChannel(askingUserID, channelID, permission)
+}
+
+//
+// Bot service.
+//
+
+func (a *serviceAPIAdapter) EnsureBot(bot *mm_model.Bot) (string, error) {
+	return a.api.botService.EnsureBot(a.ctx, boardsProductID, bot)
+}
+
+//
+// License service.
+//
+
+func (a *serviceAPIAdapter) GetLicense() *mm_model.License {
+	return a.api.licenseService.GetLicense()
+}
+
+//
+// FileInfoStore service.
+//
+
+func (a *serviceAPIAdapter) GetFileInfo(fileID string) (*mm_model.FileInfo, error) {
+	fi, appErr := a.api.fileInfoStoreService.GetFileInfo(fileID)
+	return fi, normalizeAppErr(appErr)
+}
+
+//
+// Cluster store.
+//
+
+func (a *serviceAPIAdapter) PublishWebSocketEvent(event string, payload map[string]interface{}, broadcast *mm_model.WebsocketBroadcast) {
+	a.api.clusterService.PublishWebSocketEvent(boardsProductName, event, payload, broadcast)
+}
+
+func (a *serviceAPIAdapter) PublishPluginClusterEvent(ev mm_model.PluginClusterEvent, opts mm_model.PluginClusterEventSendOptions) error {
+	return a.api.clusterService.PublishPluginClusterEvent(boardsProductName, ev, opts)
+}
+
+//
+// Cloud service.
+//
+
+func (a *serviceAPIAdapter) GetCloudLimits() (*mm_model.ProductLimits, error) {
+	return a.api.cloudService.GetCloudLimits()
+}
+
+//
+// Config service.
+//
+
+func (a *serviceAPIAdapter) GetConfig() *mm_model.Config {
+	return a.api.configService.Config()
+}
+
+//
+// Logger service.
+//
+
+func (a *serviceAPIAdapter) GetLogger() mlog.LoggerIFace {
+	return a.api.logger
+}
+
+//
+// KVStore service.
+//
+
+func (a *serviceAPIAdapter) KVSetWithOptions(key string, value []byte, options mm_model.PluginKVSetOptions) (bool, error) {
+	b, appErr := a.api.kvStoreService.SetPluginKeyWithOptions(boardsProductName, key, value, options)
+	return b, normalizeAppErr(appErr)
+}
+
+//
+// Store service.
+//
+
+func (a *serviceAPIAdapter) GetMasterDB() (*sql.DB, error) {
+	return a.api.storeService.GetMasterDB(), nil
+}
+
+//
+// System service.
+//
+
+func (a *serviceAPIAdapter) GetDiagnosticID() string {
+	return a.api.systemService.GetDiagnosticId()
+}
+
+//
+// Router service.
+//
+
+func (a *serviceAPIAdapter) RegisterRouter(sub *mux.Router) {
+	a.api.routerService.RegisterRouter(boardsProductName, sub)
+}
+
+//
+// Preferences service.
+//
+
+func (a *serviceAPIAdapter) GetPreferencesForUser(userID string) (mm_model.Preferences, error) {
+	p, appErr := a.api.preferencesService.GetPreferencesForUser(userID)
+	return p, normalizeAppErr(appErr)
+}
+
+func (a *serviceAPIAdapter) UpdatePreferencesForUser(userID string, preferences mm_model.Preferences) error {
+	appErr := a.api.preferencesService.UpdatePreferencesForUser(userID, preferences)
+	return normalizeAppErr(appErr)
+}
+
+func (a *serviceAPIAdapter) DeletePreferencesForUser(userID string, preferences mm_model.Preferences) error {
+	appErr := a.api.preferencesService.DeletePreferencesForUser(userID, preferences)
+	return normalizeAppErr(appErr)
+}
+
+// Ensure the adapter implements ServicesAPI.
+var _ model.ServicesAPI = &serviceAPIAdapter{}

server/boards/product/boards_product.go

@@ -0,0 +1,331 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package product
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/mattermost/mattermost-server/v6/server/boards/model"
+	"github.com/mattermost/mattermost-server/v6/server/boards/server"
+
+	mm_model "github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/plugin"
+	"github.com/mattermost/mattermost-server/v6/server/channels/product"
+	"github.com/mattermost/mattermost-server/v6/server/platform/shared/mlog"
+)
+
+const (
+	boardsProductName = "boards"
+	boardsProductID   = "com.mattermost.boards"
+)
+
+var errServiceTypeAssert = errors.New("type assertion failed")
+
+func init() {
+	product.RegisterProduct(boardsProductName, product.Manifest{
+		Initializer: newBoardsProduct,
+		Dependencies: map[product.ServiceKey]struct{}{
+			product.TeamKey:          {},
+			product.ChannelKey:       {},
+			product.UserKey:          {},
+			product.PostKey:          {},
+			product.PermissionsKey:   {},
+			product.BotKey:           {},
+			product.ClusterKey:       {},
+			product.ConfigKey:        {},
+			product.LogKey:           {},
+			product.LicenseKey:       {},
+			product.FilestoreKey:     {},
+			product.FileInfoStoreKey: {},
+			product.RouterKey:        {},
+			product.CloudKey:         {},
+			product.KVStoreKey:       {},
+			product.StoreKey:         {},
+			product.SystemKey:        {},
+			product.PreferencesKey:   {},
+			product.HooksKey:         {},
+		},
+	})
+}
+
+type boardsProduct struct {
+	teamService          product.TeamService
+	channelService       product.ChannelService
+	userService          product.UserService
+	postService          product.PostService
+	permissionsService   product.PermissionService
+	botService           product.BotService
+	clusterService       product.ClusterService
+	configService        product.ConfigService
+	logger               mlog.LoggerIFace
+	licenseService       product.LicenseService
+	filestoreService     product.FilestoreService
+	fileInfoStoreService product.FileInfoStoreService
+	routerService        product.RouterService
+	cloudService         product.CloudService
+	kvStoreService       product.KVStoreService
+	storeService         product.StoreService
+	systemService        product.SystemService
+	preferencesService   product.PreferencesService
+	hooksService         product.HooksService
+
+	boardsApp *server.BoardsService
+}
+
+func newBoardsProduct(services map[product.ServiceKey]interface{}) (product.Product, error) {
+	boardsProd := &boardsProduct{}
+
+	if err := populateServices(boardsProd, services); err != nil {
+		return nil, err
+	}
+
+	boardsProd.logger.Info("Creating boards service")
+
+	adapter := newServiceAPIAdapter(boardsProd)
+	boardsApp, err := server.NewBoardsService(adapter)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create Boards service: %w", err)
+	}
+
+	boardsProd.boardsApp = boardsApp
+
+	// Add the Boards services API to the services map so other products can access Boards functionality.
+	boardsAPI := server.NewBoardsServiceAPI(boardsApp)
+	services[product.BoardsKey] = boardsAPI
+
+	return boardsProd, nil
+}
+
+// populateServices populates the boardProduct with all the services needed from the suite.
+func populateServices(boardsProd *boardsProduct, services map[product.ServiceKey]interface{}) error {
+	for key, service := range services {
+		switch key {
+		case product.TeamKey:
+			teamService, ok := service.(product.TeamService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.teamService = teamService
+		case product.ChannelKey:
+			channelService, ok := service.(product.ChannelService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.channelService = channelService
+		case product.UserKey:
+			userService, ok := service.(product.UserService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.userService = userService
+		case product.PostKey:
+			postService, ok := service.(product.PostService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.postService = postService
+		case product.PermissionsKey:
+			permissionsService, ok := service.(product.PermissionService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.permissionsService = permissionsService
+		case product.BotKey:
+			botService, ok := service.(product.BotService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.botService = botService
+		case product.ClusterKey:
+			clusterService, ok := service.(product.ClusterService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.clusterService = clusterService
+		case product.ConfigKey:
+			configService, ok := service.(product.ConfigService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.configService = configService
+		case product.LogKey:
+			logger, ok := service.(mlog.LoggerIFace)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.logger = logger.With(mlog.String("product", boardsProductName))
+		case product.LicenseKey:
+			licenseService, ok := service.(product.LicenseService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.licenseService = licenseService
+		case product.FilestoreKey:
+			filestoreService, ok := service.(product.FilestoreService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.filestoreService = filestoreService
+		case product.FileInfoStoreKey:
+			fileInfoStoreService, ok := service.(product.FileInfoStoreService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.fileInfoStoreService = fileInfoStoreService
+		case product.RouterKey:
+			routerService, ok := service.(product.RouterService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.routerService = routerService
+		case product.CloudKey:
+			cloudService, ok := service.(product.CloudService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.cloudService = cloudService
+		case product.KVStoreKey:
+			kvStoreService, ok := service.(product.KVStoreService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.kvStoreService = kvStoreService
+		case product.StoreKey:
+			storeService, ok := service.(product.StoreService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.storeService = storeService
+		case product.SystemKey:
+			systemService, ok := service.(product.SystemService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.systemService = systemService
+		case product.PreferencesKey:
+			preferencesService, ok := service.(product.PreferencesService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.preferencesService = preferencesService
+		case product.HooksKey:
+			hooksService, ok := service.(product.HooksService)
+			if !ok {
+				return fmt.Errorf("invalid service key '%s': %w", key, errServiceTypeAssert)
+			}
+			boardsProd.hooksService = hooksService
+		}
+	}
+	return nil
+}
+
+func (bp *boardsProduct) Start() error {
+	if !bp.configService.Config().FeatureFlags.BoardsProduct {
+		bp.logger.Info("Boards product disabled via feature flag")
+		return nil
+	}
+
+	bp.logger.Info("Starting boards service")
+
+	adapter := newServiceAPIAdapter(bp)
+	boardsApp, err := server.NewBoardsService(adapter)
+	if err != nil {
+		return fmt.Errorf("failed to create Boards service: %w", err)
+	}
+
+	model.LogServerInfo(bp.logger)
+
+	if err := bp.hooksService.RegisterHooks(boardsProductName, bp); err != nil {
+		return fmt.Errorf("failed to register hooks: %w", err)
+	}
+
+	bp.boardsApp = boardsApp
+	if err := bp.boardsApp.Start(); err != nil {
+		return fmt.Errorf("failed to start Boards service: %w", err)
+	}
+
+	return nil
+}
+
+func (bp *boardsProduct) Stop() error {
+	bp.logger.Info("Stopping boards service")
+
+	if bp.boardsApp == nil {
+		return nil
+	}
+
+	if err := bp.boardsApp.Stop(); err != nil {
+		return fmt.Errorf("error while stopping Boards service: %w", err)
+	}
+
+	return nil
+}
+
+//
+// These callbacks are called by the suite automatically
+//
+
+func (bp *boardsProduct) OnConfigurationChange() error {
+	if bp.boardsApp == nil {
+		return nil
+	}
+	return bp.boardsApp.OnConfigurationChange()
+}
+
+func (bp *boardsProduct) OnWebSocketConnect(webConnID, userID string) {
+	if bp.boardsApp == nil {
+		return
+	}
+	bp.boardsApp.OnWebSocketConnect(webConnID, userID)
+}
+
+func (bp *boardsProduct) OnWebSocketDisconnect(webConnID, userID string) {
+	if bp.boardsApp == nil {
+		return
+	}
+	bp.boardsApp.OnWebSocketDisconnect(webConnID, userID)
+}
+
+func (bp *boardsProduct) WebSocketMessageHasBeenPosted(webConnID, userID string, req *mm_model.WebSocketRequest) {
+	if bp.boardsApp == nil {
+		return
+	}
+	bp.boardsApp.WebSocketMessageHasBeenPosted(webConnID, userID, req)
+}
+
+func (bp *boardsProduct) OnPluginClusterEvent(ctx *plugin.Context, ev mm_model.PluginClusterEvent) {
+	if bp.boardsApp == nil {
+		return
+	}
+	bp.boardsApp.OnPluginClusterEvent(ctx, ev)
+}
+
+func (bp *boardsProduct) MessageWillBePosted(ctx *plugin.Context, post *mm_model.Post) (*mm_model.Post, string) {
+	if bp.boardsApp == nil {
+		return post, ""
+	}
+	return bp.boardsApp.MessageWillBePosted(ctx, post)
+}
+
+func (bp *boardsProduct) MessageWillBeUpdated(ctx *plugin.Context, newPost, oldPost *mm_model.Post) (*mm_model.Post, string) {
+	if bp.boardsApp == nil {
+		return newPost, ""
+	}
+	return bp.boardsApp.MessageWillBeUpdated(ctx, newPost, oldPost)
+}
+
+func (bp *boardsProduct) OnCloudLimitsUpdated(limits *mm_model.ProductLimits) {
+	if bp.boardsApp == nil {
+		return
+	}
+	bp.boardsApp.OnCloudLimitsUpdated(limits)
+}
+
+func (bp *boardsProduct) RunDataRetention(nowTime, batchSize int64) (int64, error) {
+	if bp.boardsApp == nil {
+		return 0, nil
+	}
+	return bp.boardsApp.RunDataRetention(nowTime, batchSize)
+}

server/boards/product/imports/boards_imports.go

@@ -0,0 +1,10 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package imports
+
+import (
+	// Needed to ensure the init() method in the FocalBoard product is run.
+	// This file is copied to the mmserver imports package via makefile.
+	_ "github.com/mattermost/mattermost-server/v6/server/boards/product"
+)