3ae821d2e8
* Refactor websockets state and lifecycle This PR moves the state of the authentication and subscriptions to the websockets client, allowing for multiple components to communicate with it and request subscriptions independently. With this change, the lifecycle of the websockets client is now managed on a component, and a hook is provided for easy access to it from individual components. * Fix linter * Integrating the new websockets in channels integration with the RHS and board selector * Some small fixes around boards-channels relationship * Make the boards unfurl to always use the current team * Fixing weird behaviors in websockets and other small data related bugs in channel-board relationship * Only warn if withWebSockets is used without a base connection * Fix tests * Fix linter * Update snapshot * Fixing plugin tests Co-authored-by: Jesús Espino <jespinog@gmail.com>
870 lines
22 KiB
Go
870 lines
22 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
// Code generated by "make generate" from the Store interface
|
|
// DO NOT EDIT
|
|
|
|
// To add a public method, create an entry in the Store interface,
|
|
// prefix it with a @withTransaction comment if you need it to be
|
|
// transactional and then add a private method in the store itself
|
|
// with db sq.BaseRunner as the first parameter before running `make
|
|
// generate`
|
|
|
|
package sqlstore
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/mattermost/focalboard/server/model"
|
|
|
|
mmModel "github.com/mattermost/mattermost-server/v6/model"
|
|
"github.com/mattermost/mattermost-server/v6/shared/mlog"
|
|
)
|
|
|
|
func (s *SQLStore) AddUpdateCategoryBoard(userID string, categoryID string, blockID string) error {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.addUpdateCategoryBoard(s.db, userID, categoryID, blockID)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return txErr
|
|
}
|
|
err := s.addUpdateCategoryBoard(tx, userID, categoryID, blockID)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "AddUpdateCategoryBoard"))
|
|
}
|
|
return err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) CleanUpSessions(expireTime int64) error {
|
|
return s.cleanUpSessions(s.db, expireTime)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) CreateBoardsAndBlocks(bab *model.BoardsAndBlocks, userID string) (*model.BoardsAndBlocks, error) {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.createBoardsAndBlocks(s.db, bab, userID)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return nil, txErr
|
|
}
|
|
result, err := s.createBoardsAndBlocks(tx, bab, userID)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "CreateBoardsAndBlocks"))
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return result, nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) CreateBoardsAndBlocksWithAdmin(bab *model.BoardsAndBlocks, userID string) (*model.BoardsAndBlocks, []*model.BoardMember, error) {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.createBoardsAndBlocksWithAdmin(s.db, bab, userID)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return nil, nil, txErr
|
|
}
|
|
result, resultVar1, err := s.createBoardsAndBlocksWithAdmin(tx, bab, userID)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "CreateBoardsAndBlocksWithAdmin"))
|
|
}
|
|
return nil, nil, err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
return result, resultVar1, nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) CreateCategory(category model.Category) error {
|
|
return s.createCategory(s.db, category)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) CreateSession(session *model.Session) error {
|
|
return s.createSession(s.db, session)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) CreateSubscription(sub *model.Subscription) (*model.Subscription, error) {
|
|
return s.createSubscription(s.db, sub)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) CreateUser(user *model.User) error {
|
|
return s.createUser(s.db, user)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) DeleteBlock(blockID string, modifiedBy string) error {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.deleteBlock(s.db, blockID, modifiedBy)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return txErr
|
|
}
|
|
err := s.deleteBlock(tx, blockID, modifiedBy)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "DeleteBlock"))
|
|
}
|
|
return err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) DeleteBoard(boardID string, userID string) error {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.deleteBoard(s.db, boardID, userID)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return txErr
|
|
}
|
|
err := s.deleteBoard(tx, boardID, userID)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "DeleteBoard"))
|
|
}
|
|
return err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) DeleteBoardsAndBlocks(dbab *model.DeleteBoardsAndBlocks, userID string) error {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.deleteBoardsAndBlocks(s.db, dbab, userID)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return txErr
|
|
}
|
|
err := s.deleteBoardsAndBlocks(tx, dbab, userID)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "DeleteBoardsAndBlocks"))
|
|
}
|
|
return err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) DeleteCategory(categoryID string, userID string, teamID string) error {
|
|
return s.deleteCategory(s.db, categoryID, userID, teamID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) DeleteMember(boardID string, userID string) error {
|
|
return s.deleteMember(s.db, boardID, userID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) DeleteNotificationHint(blockID string) error {
|
|
return s.deleteNotificationHint(s.db, blockID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) DeleteSession(sessionID string) error {
|
|
return s.deleteSession(s.db, sessionID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) DeleteSubscription(blockID string, subscriberID string) error {
|
|
return s.deleteSubscription(s.db, blockID, subscriberID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) DuplicateBlock(boardID string, blockID string, userID string, asTemplate bool) ([]model.Block, error) {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.duplicateBlock(s.db, boardID, blockID, userID, asTemplate)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return nil, txErr
|
|
}
|
|
result, err := s.duplicateBlock(tx, boardID, blockID, userID, asTemplate)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "DuplicateBlock"))
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return result, nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) DuplicateBoard(boardID string, userID string, toTeam string, asTemplate bool) (*model.BoardsAndBlocks, []*model.BoardMember, error) {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.duplicateBoard(s.db, boardID, userID, toTeam, asTemplate)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return nil, nil, txErr
|
|
}
|
|
result, resultVar1, err := s.duplicateBoard(tx, boardID, userID, toTeam, asTemplate)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "DuplicateBoard"))
|
|
}
|
|
return nil, nil, err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
return result, resultVar1, nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetActiveUserCount(updatedSecondsAgo int64) (int, error) {
|
|
return s.getActiveUserCount(s.db, updatedSecondsAgo)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetAllTeams() ([]*model.Team, error) {
|
|
return s.getAllTeams(s.db)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBlock(blockID string) (*model.Block, error) {
|
|
return s.getBlock(s.db, blockID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBlockCountsByType() (map[string]int64, error) {
|
|
return s.getBlockCountsByType(s.db)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBlockHistory(blockID string, opts model.QueryBlockHistoryOptions) ([]model.Block, error) {
|
|
return s.getBlockHistory(s.db, blockID, opts)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBlockHistoryDescendants(boardID string, opts model.QueryBlockHistoryOptions) ([]model.Block, error) {
|
|
return s.getBlockHistoryDescendants(s.db, boardID, opts)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBlocksByIDs(ids []string) ([]model.Block, error) {
|
|
return s.getBlocksByIDs(s.db, ids)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBlocksForBoard(boardID string) ([]model.Block, error) {
|
|
return s.getBlocksForBoard(s.db, boardID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBlocksWithBoardID(boardID string) ([]model.Block, error) {
|
|
return s.getBlocksWithBoardID(s.db, boardID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBlocksWithParent(boardID string, parentID string) ([]model.Block, error) {
|
|
return s.getBlocksWithParent(s.db, boardID, parentID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBlocksWithParentAndType(boardID string, parentID string, blockType string) ([]model.Block, error) {
|
|
return s.getBlocksWithParentAndType(s.db, boardID, parentID, blockType)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBlocksWithType(boardID string, blockType string) ([]model.Block, error) {
|
|
return s.getBlocksWithType(s.db, boardID, blockType)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBoard(id string) (*model.Board, error) {
|
|
return s.getBoard(s.db, id)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBoardAndCard(block *model.Block) (*model.Board, *model.Block, error) {
|
|
return s.getBoardAndCard(s.db, block)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBoardAndCardByID(blockID string) (*model.Board, *model.Block, error) {
|
|
return s.getBoardAndCardByID(s.db, blockID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBoardHistory(boardID string, opts model.QueryBoardHistoryOptions) ([]*model.Board, error) {
|
|
return s.getBoardHistory(s.db, boardID, opts)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBoardMemberHistory(boardID string, userID string, limit uint64) ([]*model.BoardMemberHistoryEntry, error) {
|
|
return s.getBoardMemberHistory(s.db, boardID, userID, limit)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBoardsForUserAndTeam(userID string, teamID string) ([]*model.Board, error) {
|
|
return s.getBoardsForUserAndTeam(s.db, userID, teamID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetBoardsInTeamByIds(boardIDs []string, teamID string) ([]*model.Board, error) {
|
|
return s.getBoardsInTeamByIds(s.db, boardIDs, teamID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetCardLimitTimestamp() (int64, error) {
|
|
return s.getCardLimitTimestamp(s.db)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetCategory(id string) (*model.Category, error) {
|
|
return s.getCategory(s.db, id)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetChannel(teamID string, channelID string) (*mmModel.Channel, error) {
|
|
return s.getChannel(s.db, teamID, channelID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetCloudLimits() (*mmModel.ProductLimits, error) {
|
|
return s.getCloudLimits(s.db)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetFileInfo(id string) (*mmModel.FileInfo, error) {
|
|
return s.getFileInfo(s.db, id)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetLicense() *mmModel.License {
|
|
return s.getLicense(s.db)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetMemberForBoard(boardID string, userID string) (*model.BoardMember, error) {
|
|
return s.getMemberForBoard(s.db, boardID, userID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetMembersForBoard(boardID string) ([]*model.BoardMember, error) {
|
|
return s.getMembersForBoard(s.db, boardID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetMembersForUser(userID string) ([]*model.BoardMember, error) {
|
|
return s.getMembersForUser(s.db, userID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetNextNotificationHint(remove bool) (*model.NotificationHint, error) {
|
|
return s.getNextNotificationHint(s.db, remove)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetNotificationHint(blockID string) (*model.NotificationHint, error) {
|
|
return s.getNotificationHint(s.db, blockID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetRegisteredUserCount() (int, error) {
|
|
return s.getRegisteredUserCount(s.db)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetSession(token string, expireTime int64) (*model.Session, error) {
|
|
return s.getSession(s.db, token, expireTime)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetSharing(rootID string) (*model.Sharing, error) {
|
|
return s.getSharing(s.db, rootID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetSubTree2(boardID string, blockID string, opts model.QuerySubtreeOptions) ([]model.Block, error) {
|
|
return s.getSubTree2(s.db, boardID, blockID, opts)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetSubscribersCountForBlock(blockID string) (int, error) {
|
|
return s.getSubscribersCountForBlock(s.db, blockID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetSubscribersForBlock(blockID string) ([]*model.Subscriber, error) {
|
|
return s.getSubscribersForBlock(s.db, blockID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetSubscription(blockID string, subscriberID string) (*model.Subscription, error) {
|
|
return s.getSubscription(s.db, blockID, subscriberID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetSubscriptions(subscriberID string) ([]*model.Subscription, error) {
|
|
return s.getSubscriptions(s.db, subscriberID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetSystemSetting(key string) (string, error) {
|
|
return s.getSystemSetting(s.db, key)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetSystemSettings() (map[string]string, error) {
|
|
return s.getSystemSettings(s.db)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetTeam(ID string) (*model.Team, error) {
|
|
return s.getTeam(s.db, ID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetTeamCount() (int64, error) {
|
|
return s.getTeamCount(s.db)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetTeamsForUser(userID string) ([]*model.Team, error) {
|
|
return s.getTeamsForUser(s.db, userID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetTemplateBoards(teamID string, userID string) ([]*model.Board, error) {
|
|
return s.getTemplateBoards(s.db, teamID, userID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetUsedCardsCount() (int, error) {
|
|
return s.getUsedCardsCount(s.db)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetUserByEmail(email string) (*model.User, error) {
|
|
return s.getUserByEmail(s.db, email)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetUserByID(userID string) (*model.User, error) {
|
|
return s.getUserByID(s.db, userID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetUserByUsername(username string) (*model.User, error) {
|
|
return s.getUserByUsername(s.db, username)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetUserCategoryBoards(userID string, teamID string) ([]model.CategoryBoards, error) {
|
|
return s.getUserCategoryBoards(s.db, userID, teamID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) GetUsersByTeam(teamID string) ([]*model.User, error) {
|
|
return s.getUsersByTeam(s.db, teamID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) InsertBlock(block *model.Block, userID string) error {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.insertBlock(s.db, block, userID)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return txErr
|
|
}
|
|
err := s.insertBlock(tx, block, userID)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "InsertBlock"))
|
|
}
|
|
return err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) InsertBlocks(blocks []model.Block, userID string) error {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.insertBlocks(s.db, blocks, userID)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return txErr
|
|
}
|
|
err := s.insertBlocks(tx, blocks, userID)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "InsertBlocks"))
|
|
}
|
|
return err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) InsertBoard(board *model.Board, userID string) (*model.Board, error) {
|
|
return s.insertBoard(s.db, board, userID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) InsertBoardWithAdmin(board *model.Board, userID string) (*model.Board, *model.BoardMember, error) {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.insertBoardWithAdmin(s.db, board, userID)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return nil, nil, txErr
|
|
}
|
|
result, resultVar1, err := s.insertBoardWithAdmin(tx, board, userID)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "InsertBoardWithAdmin"))
|
|
}
|
|
return nil, nil, err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
|
|
return result, resultVar1, nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) PatchBlock(blockID string, blockPatch *model.BlockPatch, userID string) error {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.patchBlock(s.db, blockID, blockPatch, userID)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return txErr
|
|
}
|
|
err := s.patchBlock(tx, blockID, blockPatch, userID)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "PatchBlock"))
|
|
}
|
|
return err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) PatchBlocks(blockPatches *model.BlockPatchBatch, userID string) error {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.patchBlocks(s.db, blockPatches, userID)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return txErr
|
|
}
|
|
err := s.patchBlocks(tx, blockPatches, userID)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "PatchBlocks"))
|
|
}
|
|
return err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) PatchBoard(boardID string, boardPatch *model.BoardPatch, userID string) (*model.Board, error) {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.patchBoard(s.db, boardID, boardPatch, userID)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return nil, txErr
|
|
}
|
|
result, err := s.patchBoard(tx, boardID, boardPatch, userID)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "PatchBoard"))
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return result, nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) PatchBoardsAndBlocks(pbab *model.PatchBoardsAndBlocks, userID string) (*model.BoardsAndBlocks, error) {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.patchBoardsAndBlocks(s.db, pbab, userID)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return nil, txErr
|
|
}
|
|
result, err := s.patchBoardsAndBlocks(tx, pbab, userID)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "PatchBoardsAndBlocks"))
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return result, nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) PatchUserProps(userID string, patch model.UserPropPatch) error {
|
|
return s.patchUserProps(s.db, userID, patch)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) RefreshSession(session *model.Session) error {
|
|
return s.refreshSession(s.db, session)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) RemoveDefaultTemplates(boards []*model.Board) error {
|
|
return s.removeDefaultTemplates(s.db, boards)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) RunDataRetention(globalRetentionDate int64, batchSize int64) (int64, error) {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.runDataRetention(s.db, globalRetentionDate, batchSize)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return 0, txErr
|
|
}
|
|
result, err := s.runDataRetention(tx, globalRetentionDate, batchSize)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "RunDataRetention"))
|
|
}
|
|
return 0, err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
return result, nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) SaveFileInfo(fileInfo *mmModel.FileInfo) error {
|
|
return s.saveFileInfo(s.db, fileInfo)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) SaveMember(bm *model.BoardMember) (*model.BoardMember, error) {
|
|
return s.saveMember(s.db, bm)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) SearchBoardsForUser(term string, userID string) ([]*model.Board, error) {
|
|
return s.searchBoardsForUser(s.db, term, userID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) SearchBoardsForUserInTeam(teamID string, term string, userID string) ([]*model.Board, error) {
|
|
return s.searchBoardsForUserInTeam(s.db, teamID, term, userID)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) SearchUserChannels(teamID string, userID string, query string) ([]*mmModel.Channel, error) {
|
|
return s.searchUserChannels(s.db, teamID, userID, query)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) SearchUsersByTeam(teamID string, searchQuery string) ([]*model.User, error) {
|
|
return s.searchUsersByTeam(s.db, teamID, searchQuery)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) SendMessage(message string, postType string, receipts []string) error {
|
|
return s.sendMessage(s.db, message, postType, receipts)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) SetSystemSetting(key string, value string) error {
|
|
return s.setSystemSetting(s.db, key, value)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) UndeleteBlock(blockID string, modifiedBy string) error {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.undeleteBlock(s.db, blockID, modifiedBy)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return txErr
|
|
}
|
|
err := s.undeleteBlock(tx, blockID, modifiedBy)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "UndeleteBlock"))
|
|
}
|
|
return err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) UndeleteBoard(boardID string, modifiedBy string) error {
|
|
if s.dbType == model.SqliteDBType {
|
|
return s.undeleteBoard(s.db, boardID, modifiedBy)
|
|
}
|
|
tx, txErr := s.db.BeginTx(context.Background(), nil)
|
|
if txErr != nil {
|
|
return txErr
|
|
}
|
|
err := s.undeleteBoard(tx, boardID, modifiedBy)
|
|
if err != nil {
|
|
if rollbackErr := tx.Rollback(); rollbackErr != nil {
|
|
s.logger.Error("transaction rollback error", mlog.Err(rollbackErr), mlog.String("methodName", "UndeleteBoard"))
|
|
}
|
|
return err
|
|
}
|
|
|
|
if err := tx.Commit(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func (s *SQLStore) UpdateCardLimitTimestamp(cardLimit int) (int64, error) {
|
|
return s.updateCardLimitTimestamp(s.db, cardLimit)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) UpdateCategory(category model.Category) error {
|
|
return s.updateCategory(s.db, category)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) UpdateSession(session *model.Session) error {
|
|
return s.updateSession(s.db, session)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) UpdateSubscribersNotifiedAt(blockID string, notifiedAt int64) error {
|
|
return s.updateSubscribersNotifiedAt(s.db, blockID, notifiedAt)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) UpdateUser(user *model.User) error {
|
|
return s.updateUser(s.db, user)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) UpdateUserPassword(username string, password string) error {
|
|
return s.updateUserPassword(s.db, username, password)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) UpdateUserPasswordByID(userID string, password string) error {
|
|
return s.updateUserPasswordByID(s.db, userID, password)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) UpsertNotificationHint(hint *model.NotificationHint, notificationFreq time.Duration) (*model.NotificationHint, error) {
|
|
return s.upsertNotificationHint(s.db, hint, notificationFreq)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) UpsertSharing(sharing model.Sharing) error {
|
|
return s.upsertSharing(s.db, sharing)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) UpsertTeamSettings(team model.Team) error {
|
|
return s.upsertTeamSettings(s.db, team)
|
|
|
|
}
|
|
|
|
func (s *SQLStore) UpsertTeamSignupToken(team model.Team) error {
|
|
return s.upsertTeamSignupToken(s.db, team)
|
|
|
|
}
|