Revert dnd (#4294)

* Revert "Fixed bug where boards would move to category of a different team (#4284)"

This reverts commit e075f408d3.

* Revert "Merge branch 'main' into only-explicit-boards-on-default-category"

This reverts commit 7db7e56296, reversing
changes made to 3feda10b6d.

* Revert "DND support for category and boards in LHS (#3964)"

This reverts commit 9918a0b3f8.

server/app/boards.go

@@ -175,7 +175,7 @@ func (a *App) setBoardCategoryFromSource(sourceBoardID, destinationBoardID, user
 
 	// now that we have source board's category,
 	// we send destination board to the same category
-	return a.AddUpdateUserCategoryBoard(teamID, userID, map[string]string{destinationBoardID: destinationCategoryID})
+	return a.AddUpdateUserCategoryBoard(teamID, userID, destinationCategoryID, destinationBoardID)
 }
 
 func (a *App) DuplicateBoard(boardID, userID, toTeam string, asTemplate bool) (*model.BoardsAndBlocks, []*model.BoardMember, error) {
@@ -327,13 +327,10 @@ func (a *App) addBoardsToDefaultCategory(userID, teamID string, boards []*model.
 		return fmt.Errorf("%w userID: %s", errNoDefaultCategoryFound, userID)
 	}
 
-	boardCategoryMapping := map[string]string{}
 	for _, board := range boards {
-		boardCategoryMapping[board.ID] = defaultCategoryID
-	}
-
-	if err := a.AddUpdateUserCategoryBoard(teamID, userID, boardCategoryMapping); err != nil {
-		return err
+		if err := a.AddUpdateUserCategoryBoard(teamID, userID, defaultCategoryID, board.ID); err != nil {
+			return err
+		}
 	}
 
 	return nil

server/app/boards_test.go

@@ -52,7 +52,7 @@ func TestAddMemberToBoard(t *testing.T) {
 				},
 			},
 		}, nil)
-		th.Store.EXPECT().AddUpdateCategoryBoard("user_id_1", map[string]string{"board_id_1": "default_category_id"}).Return(nil)
+		th.Store.EXPECT().AddUpdateCategoryBoard("user_id_1", "default_category_id", "board_id_1").Return(nil)
 
 		addedBoardMember, err := th.App.AddMemberToBoard(boardMember)
 		require.NoError(t, err)
@@ -126,7 +126,7 @@ func TestAddMemberToBoard(t *testing.T) {
 				},
 			},
 		}, nil)
-		th.Store.EXPECT().AddUpdateCategoryBoard("user_id_1", map[string]string{"board_id_1": "default_category_id"}).Return(nil)
+		th.Store.EXPECT().AddUpdateCategoryBoard("user_id_1", "default_category_id", "board_id_1").Return(nil)
 
 		addedBoardMember, err := th.App.AddMemberToBoard(boardMember)
 		require.NoError(t, err)
@@ -434,12 +434,9 @@ func TestBoardCategory(t *testing.T) {
 				Name: "Boards",
 			}, nil)
 			th.Store.EXPECT().GetMembersForUser("user_id").Return([]*model.BoardMember{}, nil)
-			th.Store.EXPECT().GetBoardsForUserAndTeam("user_id", "team_id", false).Return([]*model.Board{}, nil)
-			th.Store.EXPECT().AddUpdateCategoryBoard("user_id", map[string]string{
-				"board_id_1": "default_category_id",
-				"board_id_2": "default_category_id",
-				"board_id_3": "default_category_id",
-			}).Return(nil)
+			th.Store.EXPECT().AddUpdateCategoryBoard("user_id", "default_category_id", "board_id_1").Return(nil)
+			th.Store.EXPECT().AddUpdateCategoryBoard("user_id", "default_category_id", "board_id_2").Return(nil)
+			th.Store.EXPECT().AddUpdateCategoryBoard("user_id", "default_category_id", "board_id_3").Return(nil)
 
 			boards := []*model.Board{
 				{ID: "board_id_1"},
@@ -452,55 +449,3 @@ func TestBoardCategory(t *testing.T) {
 		})
 	})
 }
-
-func TestDuplicateBoard(t *testing.T) {
-	th, tearDown := SetupTestHelper(t)
-	defer tearDown()
-
-	t.Run("base case", func(t *testing.T) {
-		board := &model.Board{
-			ID:    "board_id_2",
-			Title: "Duplicated Board",
-		}
-
-		block := &model.Block{
-			ID:   "block_id_1",
-			Type: "image",
-		}
-
-		th.Store.EXPECT().DuplicateBoard("board_id_1", "user_id_1", "team_id_1", false).Return(
-			&model.BoardsAndBlocks{
-				Boards: []*model.Board{
-					board,
-				},
-				Blocks: []*model.Block{
-					block,
-				},
-			},
-			[]*model.BoardMember{},
-			nil,
-		)
-
-		th.Store.EXPECT().GetBoard("board_id_1").Return(&model.Board{}, nil)
-
-		th.Store.EXPECT().GetUserCategoryBoards("user_id_1", "team_id_1").Return([]model.CategoryBoards{
-			{
-				Category: model.Category{
-					ID:   "category_id_1",
-					Name: "Boards",
-					Type: "system",
-				},
-			},
-		}, nil).Times(2)
-
-		th.Store.EXPECT().AddUpdateCategoryBoard("user_id_1", utils.Anything).Return(nil)
-
-		// for WS change broadcast
-		th.Store.EXPECT().GetMembersForBoard(utils.Anything).Return([]*model.BoardMember{}, nil).Times(2)
-
-		bab, members, err := th.App.DuplicateBoard("board_id_1", "user_id_1", "team_id_1", false)
-		assert.NoError(t, err)
-		assert.NotNil(t, bab)
-		assert.NotNil(t, members)
-	})
-}

server/app/category.go

@@ -2,21 +2,15 @@ package app
 
 import (
 	"errors"
-	"fmt"
+	"strings"
 
 	"github.com/mattermost/focalboard/server/model"
 	"github.com/mattermost/focalboard/server/utils"
 )
 
-var errCategoryNotFound = errors.New("category ID specified in input does not exist for user")
-var errCategoriesLengthMismatch = errors.New("cannot update category order, passed list of categories different size than in database")
 var ErrCannotDeleteSystemCategory = errors.New("cannot delete a system category")
 var ErrCannotUpdateSystemCategory = errors.New("cannot update a system category")
 
-func (a *App) GetCategory(categoryID string) (*model.Category, error) {
-	return a.store.GetCategory(categoryID)
-}
-
 func (a *App) CreateCategory(category *model.Category) (*model.Category, error) {
 	category.Hydrate()
 	if err := category.IsValid(); err != nil {
@@ -40,8 +34,10 @@ func (a *App) CreateCategory(category *model.Category) (*model.Category, error)
 }
 
 func (a *App) UpdateCategory(category *model.Category) (*model.Category, error) {
-	category.Hydrate()
-
+	// set to default category, UI doesn't create with Type
+	if strings.TrimSpace(category.Type) == "" {
+		category.Type = model.CategoryTypeCustom
+	}
 	if err := category.IsValid(); err != nil {
 		return nil, err
 	}
@@ -119,10 +115,6 @@ func (a *App) DeleteCategory(categoryID, userID, teamID string) (*model.Category
 		return nil, ErrCannotDeleteSystemCategory
 	}
 
-	if err = a.moveBoardsToDefaultCategory(userID, teamID, categoryID); err != nil {
-		return nil, err
-	}
-
 	if err = a.store.DeleteCategory(categoryID, userID, teamID); err != nil {
 		return nil, err
 	}
@@ -138,109 +130,3 @@ func (a *App) DeleteCategory(categoryID, userID, teamID string) (*model.Category
 
 	return deletedCategory, nil
 }
-
-func (a *App) moveBoardsToDefaultCategory(userID, teamID, sourceCategoryID string) error {
-	// we need a list of boards associated to this category
-	// so we can move them to user's default Boards category
-	categoryBoards, err := a.GetUserCategoryBoards(userID, teamID)
-	if err != nil {
-		return err
-	}
-
-	var sourceCategoryBoards *model.CategoryBoards
-	defaultCategoryID := ""
-
-	// iterate user's categories to find the source category
-	// and the default category.
-	// We need source category to get the list of its board
-	// and the default category to know its ID to
-	// move source category's boards to.
-	for i := range categoryBoards {
-		if categoryBoards[i].ID == sourceCategoryID {
-			sourceCategoryBoards = &categoryBoards[i]
-		}
-
-		if categoryBoards[i].Name == defaultCategoryBoards {
-			defaultCategoryID = categoryBoards[i].ID
-		}
-
-		// if both categories are found, no need to iterate furthur.
-		if sourceCategoryBoards != nil && defaultCategoryID != "" {
-			break
-		}
-	}
-
-	if sourceCategoryBoards == nil {
-		return errCategoryNotFound
-	}
-
-	if defaultCategoryID == "" {
-		return fmt.Errorf("moveBoardsToDefaultCategory: %w", errNoDefaultCategoryFound)
-	}
-
-	boardCategoryMapping := map[string]string{}
-
-	for _, boardID := range sourceCategoryBoards.BoardIDs {
-		boardCategoryMapping[boardID] = defaultCategoryID
-	}
-
-	if err := a.AddUpdateUserCategoryBoard(teamID, userID, boardCategoryMapping); err != nil {
-		return fmt.Errorf("moveBoardsToDefaultCategory: %w", err)
-	}
-
-	return nil
-}
-
-func (a *App) ReorderCategories(userID, teamID string, newCategoryOrder []string) ([]string, error) {
-	if err := a.verifyNewCategoriesMatchExisting(userID, teamID, newCategoryOrder); err != nil {
-		return nil, err
-	}
-
-	newOrder, err := a.store.ReorderCategories(userID, teamID, newCategoryOrder)
-	if err != nil {
-		return nil, err
-	}
-
-	go func() {
-		a.wsAdapter.BroadcastCategoryReorder(teamID, userID, newOrder)
-	}()
-
-	return newOrder, nil
-}
-
-func (a *App) verifyNewCategoriesMatchExisting(userID, teamID string, newCategoryOrder []string) error {
-	existingCategories, err := a.store.GetUserCategories(userID, teamID)
-	if err != nil {
-		return err
-	}
-
-	if len(newCategoryOrder) != len(existingCategories) {
-		return fmt.Errorf(
-			"%w length new categories: %d, length existing categories: %d, userID: %s, teamID: %s",
-			errCategoriesLengthMismatch,
-			len(newCategoryOrder),
-			len(existingCategories),
-			userID,
-			teamID,
-		)
-	}
-
-	existingCategoriesMap := map[string]bool{}
-	for _, category := range existingCategories {
-		existingCategoriesMap[category.ID] = true
-	}
-
-	for _, newCategoryID := range newCategoryOrder {
-		if _, found := existingCategoriesMap[newCategoryID]; !found {
-			return fmt.Errorf(
-				"%w specified category ID: %s, userID: %s, teamID: %s",
-				errCategoryNotFound,
-				newCategoryID,
-				userID,
-				teamID,
-			)
-		}
-	}
-
-	return nil
-}

server/app/category_boards.go

@@ -1,7 +1,6 @@
 package app
 
 import (
-	"errors"
 	"fmt"
 
 	"github.com/mattermost/focalboard/server/model"
@@ -9,10 +8,6 @@ import (
 
 const defaultCategoryBoards = "Boards"
 
-var errCategoryBoardsLengthMismatch = errors.New("cannot update category boards order, passed list of categories boards different size than in database")
-var errBoardNotFoundInCategory = errors.New("specified board ID not found in specified category ID")
-var errBoardMembershipNotFound = errors.New("board membership not found for user's board")
-
 func (a *App) GetUserCategoryBoards(userID, teamID string) ([]model.CategoryBoards, error) {
 	categoryBoards, err := a.store.GetUserCategoryBoards(userID, teamID)
 	if err != nil {
@@ -58,7 +53,6 @@ func (a *App) createBoardsCategory(userID, teamID string, existingCategoryBoards
 		TeamID:    teamID,
 		Collapsed: false,
 		Type:      model.CategoryTypeSystem,
-		SortOrder: len(existingCategoryBoards) * model.CategoryBoardsSortOrderGap,
 	}
 	createdCategory, err := a.CreateCategory(&category)
 	if err != nil {
@@ -67,40 +61,23 @@ func (a *App) createBoardsCategory(userID, teamID string, existingCategoryBoards
 
 	// once the category is created, we need to move all boards which do not
 	// belong to any category, into this category.
-
 	boardMembers, err := a.GetMembersForUser(userID)
 	if err != nil {
 		return nil, fmt.Errorf("createBoardsCategory error fetching user's board memberships: %w", err)
 	}
 
-	boardMemberByBoardID := map[string]*model.BoardMember{}
-	for _, boardMember := range boardMembers {
-		boardMemberByBoardID[boardMember.BoardID] = boardMember
-	}
-
 	createdCategoryBoards := &model.CategoryBoards{
 		Category: *createdCategory,
 		BoardIDs: []string{},
 	}
 
-	// get user's current team's baords
-	userTeamBoards, err := a.GetBoardsForUserAndTeam(userID, teamID, false)
-	if err != nil {
-		return nil, fmt.Errorf("createBoardsCategory error fetching user's team's boards: %w", err)
-	}
-
-	for _, board := range userTeamBoards {
-		boardMembership, ok := boardMemberByBoardID[board.ID]
-		if !ok {
-			return nil, fmt.Errorf("createBoardsCategory: %w", errBoardMembershipNotFound)
-		}
-
+	for _, bm := range boardMembers {
 		// boards with implicit access (aka synthetic membership),
 		// should show up in LHS only when openign them explicitelly.
 		// So we don't process any synthetic membership boards
 		// and only add boards with explicit access to, to the the LHS,
 		// for example, if a user explicitelly added another user to a board.
-		if boardMembership.Synthetic {
+		if bm.Synthetic {
 			continue
 		}
 
@@ -108,7 +85,7 @@ func (a *App) createBoardsCategory(userID, teamID string, existingCategoryBoards
 
 		for _, categoryBoard := range existingCategoryBoards {
 			for _, boardID := range categoryBoard.BoardIDs {
-				if boardID == board.ID {
+				if boardID == bm.BoardID {
 					belongsToCategory = true
 					break
 				}
@@ -122,111 +99,36 @@ func (a *App) createBoardsCategory(userID, teamID string, existingCategoryBoards
 		}
 
 		if !belongsToCategory {
-			if err := a.AddUpdateUserCategoryBoard(teamID, userID, map[string]string{board.ID: createdCategory.ID}); err != nil {
+			if err := a.AddUpdateUserCategoryBoard(teamID, userID, createdCategory.ID, bm.BoardID); err != nil {
+				// ToDo: por siaca
+				// if err := a.AddUpdateUserCategoryBoard(teamID, userID, createdCategory.ID, board.ID); err != nil {
+				// ---
 				return nil, fmt.Errorf("createBoardsCategory failed to add category-less board to the default category, defaultCategoryID: %s, error: %w", createdCategory.ID, err)
 			}
 
-			createdCategoryBoards.BoardIDs = append(createdCategoryBoards.BoardIDs, board.ID)
+			createdCategoryBoards.BoardIDs = append(createdCategoryBoards.BoardIDs, bm.BoardID)
 		}
 	}
 
 	return createdCategoryBoards, nil
 }
 
-func (a *App) AddUpdateUserCategoryBoard(teamID, userID string, boardCategoryMapping map[string]string) error {
-	err := a.store.AddUpdateCategoryBoard(userID, boardCategoryMapping)
+func (a *App) AddUpdateUserCategoryBoard(teamID, userID, categoryID, boardID string) error {
+	err := a.store.AddUpdateCategoryBoard(userID, categoryID, boardID)
 	if err != nil {
 		return err
 	}
 
-	wsPayload := make([]*model.BoardCategoryWebsocketData, len(boardCategoryMapping))
-	i := 0
-	for boardID, categoryID := range boardCategoryMapping {
-		wsPayload[i] = &model.BoardCategoryWebsocketData{
-			BoardID:    boardID,
-			CategoryID: categoryID,
-		}
-		i++
-	}
-
 	a.blockChangeNotifier.Enqueue(func() error {
 		a.wsAdapter.BroadcastCategoryBoardChange(
 			teamID,
 			userID,
-			wsPayload,
-		)
+			model.BoardCategoryWebsocketData{
+				BoardID:    boardID,
+				CategoryID: categoryID,
+			})
 		return nil
 	})
 
 	return nil
 }
-
-func (a *App) ReorderCategoryBoards(userID, teamID, categoryID string, newBoardsOrder []string) ([]string, error) {
-	if err := a.verifyNewCategoryBoardsMatchExisting(userID, teamID, categoryID, newBoardsOrder); err != nil {
-		return nil, err
-	}
-
-	newOrder, err := a.store.ReorderCategoryBoards(categoryID, newBoardsOrder)
-	if err != nil {
-		return nil, err
-	}
-
-	go func() {
-		a.wsAdapter.BroadcastCategoryBoardsReorder(teamID, userID, categoryID, newOrder)
-	}()
-
-	return newOrder, nil
-}
-
-func (a *App) verifyNewCategoryBoardsMatchExisting(userID, teamID, categoryID string, newBoardsOrder []string) error {
-	// this function is to ensure that we don't miss specifying
-	// all boards of the category while reordering.
-	existingCategoryBoards, err := a.GetUserCategoryBoards(userID, teamID)
-	if err != nil {
-		return err
-	}
-
-	var targetCategoryBoards *model.CategoryBoards
-	for i := range existingCategoryBoards {
-		if existingCategoryBoards[i].Category.ID == categoryID {
-			targetCategoryBoards = &existingCategoryBoards[i]
-			break
-		}
-	}
-
-	if targetCategoryBoards == nil {
-		return fmt.Errorf("%w categoryID: %s", errCategoryNotFound, categoryID)
-	}
-
-	if len(targetCategoryBoards.BoardIDs) != len(newBoardsOrder) {
-		return fmt.Errorf(
-			"%w length new category boards: %d, length existing category boards: %d, userID: %s, teamID: %s, categoryID: %s",
-			errCategoryBoardsLengthMismatch,
-			len(newBoardsOrder),
-			len(targetCategoryBoards.BoardIDs),
-			userID,
-			teamID,
-			categoryID,
-		)
-	}
-
-	existingBoardMap := map[string]bool{}
-	for _, boardID := range targetCategoryBoards.BoardIDs {
-		existingBoardMap[boardID] = true
-	}
-
-	for _, boardID := range newBoardsOrder {
-		if _, found := existingBoardMap[boardID]; !found {
-			return fmt.Errorf(
-				"%w board ID: %s, category ID: %s, userID: %s, teamID: %s",
-				errBoardNotFoundInCategory,
-				boardID,
-				categoryID,
-				userID,
-				teamID,
-			)
-		}
-	}
-
-	return nil
-}

server/app/category_boards_test.go

@@ -21,20 +21,6 @@ func TestGetUserCategoryBoards(t *testing.T) {
 			Name: "Boards",
 		}, nil)
 
-		board1 := &model.Board{
-			ID: "board_id_1",
-		}
-
-		board2 := &model.Board{
-			ID: "board_id_2",
-		}
-
-		board3 := &model.Board{
-			ID: "board_id_3",
-		}
-
-		th.Store.EXPECT().GetBoardsForUserAndTeam("user_id", "team_id", false).Return([]*model.Board{board1, board2, board3}, nil)
-
 		th.Store.EXPECT().GetMembersForUser("user_id").Return([]*model.BoardMember{
 			{
 				BoardID:   "board_id_1",
@@ -49,9 +35,10 @@ func TestGetUserCategoryBoards(t *testing.T) {
 				Synthetic: false,
 			},
 		}, nil)
-		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", map[string]string{"board_id_1": "boards_category_id"}).Return(nil)
-		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", map[string]string{"board_id_2": "boards_category_id"}).Return(nil)
-		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", map[string]string{"board_id_3": "boards_category_id"}).Return(nil)
+
+		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", "boards_category_id", "board_id_1").Return(nil)
+		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", "boards_category_id", "board_id_2").Return(nil)
+		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", "boards_category_id", "board_id_3").Return(nil)
 
 		categoryBoards, err := th.App.GetUserCategoryBoards("user_id", "team_id")
 		assert.NoError(t, err)
@@ -72,7 +59,6 @@ func TestGetUserCategoryBoards(t *testing.T) {
 		}, nil)
 
 		th.Store.EXPECT().GetMembersForUser("user_id").Return([]*model.BoardMember{}, nil)
-		th.Store.EXPECT().GetBoardsForUserAndTeam("user_id", "team_id", false).Return([]*model.Board{}, nil)
 
 		categoryBoards, err := th.App.GetUserCategoryBoards("user_id", "team_id")
 		assert.NoError(t, err)
@@ -108,7 +94,6 @@ func TestCreateBoardsCategory(t *testing.T) {
 			Type: "system",
 			Name: "Boards",
 		}, nil)
-		th.Store.EXPECT().GetBoardsForUserAndTeam("user_id", "team_id", false).Return([]*model.Board{}, nil)
 		th.Store.EXPECT().GetMembersForUser("user_id").Return([]*model.BoardMember{}, nil)
 
 		existingCategoryBoards := []model.CategoryBoards{}
@@ -126,7 +111,6 @@ func TestCreateBoardsCategory(t *testing.T) {
 			Type: "system",
 			Name: "Boards",
 		}, nil)
-		th.Store.EXPECT().GetBoardsForUserAndTeam("user_id", "team_id", false).Return([]*model.Board{}, nil)
 		th.Store.EXPECT().GetMembersForUser("user_id").Return([]*model.BoardMember{
 			{
 				BoardID:   "board_id_1",
@@ -160,17 +144,6 @@ func TestCreateBoardsCategory(t *testing.T) {
 			Type: "system",
 			Name: "Boards",
 		}, nil)
-
-		board1 := &model.Board{
-			ID: "board_id_1",
-		}
-		board2 := &model.Board{
-			ID: "board_id_2",
-		}
-		board3 := &model.Board{
-			ID: "board_id_3",
-		}
-		th.Store.EXPECT().GetBoardsForUserAndTeam("user_id", "team_id", false).Return([]*model.Board{board1, board2, board3}, nil)
 		th.Store.EXPECT().GetMembersForUser("user_id").Return([]*model.BoardMember{
 			{
 				BoardID:   "board_id_1",
@@ -185,9 +158,9 @@ func TestCreateBoardsCategory(t *testing.T) {
 				Synthetic: false,
 			},
 		}, nil)
-		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", map[string]string{"board_id_1": "boards_category_id"}).Return(nil)
-		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", map[string]string{"board_id_2": "boards_category_id"}).Return(nil)
-		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", map[string]string{"board_id_3": "boards_category_id"}).Return(nil)
+		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", "boards_category_id", "board_id_1").Return(nil)
+		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", "boards_category_id", "board_id_2").Return(nil)
+		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", "boards_category_id", "board_id_3").Return(nil)
 
 		existingCategoryBoards := []model.CategoryBoards{}
 		boardsCategory, err := th.App.createBoardsCategory("user_id", "team_id", existingCategoryBoards)
@@ -207,11 +180,6 @@ func TestCreateBoardsCategory(t *testing.T) {
 			Type: "system",
 			Name: "Boards",
 		}, nil)
-
-		board1 := &model.Board{
-			ID: "board_id_1",
-		}
-		th.Store.EXPECT().GetBoardsForUserAndTeam("user_id", "team_id", false).Return([]*model.Board{board1}, nil)
 		th.Store.EXPECT().GetMembersForUser("user_id").Return([]*model.BoardMember{
 			{
 				BoardID:   "board_id_1",
@@ -226,7 +194,7 @@ func TestCreateBoardsCategory(t *testing.T) {
 				Synthetic: true,
 			},
 		}, nil)
-		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", map[string]string{"board_id_1": "boards_category_id"}).Return(nil)
+		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", "boards_category_id", "board_id_1").Return(nil)
 
 		existingCategoryBoards := []model.CategoryBoards{}
 		boardsCategory, err := th.App.createBoardsCategory("user_id", "team_id", existingCategoryBoards)
@@ -240,54 +208,3 @@ func TestCreateBoardsCategory(t *testing.T) {
 		assert.Equal(t, 1, len(boardsCategory.BoardIDs))
 	})
 }
-
-func TestReorderCategoryBoards(t *testing.T) {
-	th, tearDown := SetupTestHelper(t)
-	defer tearDown()
-
-	t.Run("base case", func(t *testing.T) {
-		th.Store.EXPECT().GetUserCategoryBoards("user_id", "team_id").Return([]model.CategoryBoards{
-			{
-				Category: model.Category{ID: "category_id_1", Name: "Category 1"},
-				BoardIDs: []string{"board_id_1", "board_id_2"},
-			},
-			{
-				Category: model.Category{ID: "category_id_2", Name: "Boards", Type: "system"},
-				BoardIDs: []string{"board_id_3"},
-			},
-			{
-				Category: model.Category{ID: "category_id_3", Name: "Category 3"},
-				BoardIDs: []string{},
-			},
-		}, nil)
-
-		th.Store.EXPECT().ReorderCategoryBoards("category_id_1", []string{"board_id_2", "board_id_1"}).Return([]string{"board_id_2", "board_id_1"}, nil)
-
-		newOrder, err := th.App.ReorderCategoryBoards("user_id", "team_id", "category_id_1", []string{"board_id_2", "board_id_1"})
-		assert.NoError(t, err)
-		assert.Equal(t, 2, len(newOrder))
-		assert.Equal(t, "board_id_2", newOrder[0])
-		assert.Equal(t, "board_id_1", newOrder[1])
-	})
-
-	t.Run("not specifying all boards", func(t *testing.T) {
-		th.Store.EXPECT().GetUserCategoryBoards("user_id", "team_id").Return([]model.CategoryBoards{
-			{
-				Category: model.Category{ID: "category_id_1", Name: "Category 1"},
-				BoardIDs: []string{"board_id_1", "board_id_2", "board_id_3"},
-			},
-			{
-				Category: model.Category{ID: "category_id_2", Name: "Boards", Type: "system"},
-				BoardIDs: []string{"board_id_3"},
-			},
-			{
-				Category: model.Category{ID: "category_id_3", Name: "Category 3"},
-				BoardIDs: []string{},
-			},
-		}, nil)
-
-		newOrder, err := th.App.ReorderCategoryBoards("user_id", "team_id", "category_id_1", []string{"board_id_2", "board_id_1"})
-		assert.Error(t, err)
-		assert.Nil(t, newOrder)
-	})
-}

server/app/category_test.go

@@ -92,14 +92,6 @@ func TestUpdateCategory(t *testing.T) {
 	})
 
 	t.Run("updating invalid category", func(t *testing.T) {
-		th.Store.EXPECT().GetCategory(utils.Anything).Return(&model.Category{
-			ID:     "category_id_1",
-			Name:   "Category",
-			TeamID: "team_id_1",
-			UserID: "user_id_1",
-			Type:   "custom",
-		}, nil)
-
 		category := &model.Category{
 			ID:     "category_id_1",
 			Name:   "Name",
@@ -268,33 +260,6 @@ func TestDeleteCategory(t *testing.T) {
 			DeleteAt: 10000,
 		}, nil)
 
-		th.Store.EXPECT().GetUserCategoryBoards("user_id_1", "team_id_1").Return([]model.CategoryBoards{
-			{
-				Category: model.Category{
-					ID:       "category_id_default",
-					DeleteAt: 0,
-					UserID:   "user_id_1",
-					TeamID:   "team_id_1",
-					Type:     "default",
-					Name:     "Boards",
-				},
-				BoardIDs: []string{},
-			},
-			{
-				Category: model.Category{
-					ID:       "category_id_1",
-					DeleteAt: 0,
-					UserID:   "user_id_1",
-					TeamID:   "team_id_1",
-					Type:     "custom",
-					Name:     "Category 1",
-				},
-				BoardIDs: []string{},
-			},
-		}, nil)
-
-		th.Store.EXPECT().AddUpdateCategoryBoard("user_id_1", utils.Anything).Return(nil)
-
 		deletedCategory, err := th.App.DeleteCategory("category_id_1", "user_id_1", "team_id_1")
 		assert.NotNil(t, deletedCategory)
 		assert.NoError(t, err)
@@ -328,171 +293,3 @@ func TestDeleteCategory(t *testing.T) {
 		assert.Error(t, err)
 	})
 }
-
-func TestMoveBoardsToDefaultCategory(t *testing.T) {
-	th, tearDown := SetupTestHelper(t)
-	defer tearDown()
-
-	t.Run("When default category already exists", func(t *testing.T) {
-		th.Store.EXPECT().GetUserCategoryBoards("user_id", "team_id").Return([]model.CategoryBoards{
-			{
-				Category: model.Category{
-					ID:   "category_id_1",
-					Name: "Boards",
-					Type: "system",
-				},
-			},
-			{
-				Category: model.Category{
-					ID:   "category_id_2",
-					Name: "Custom Category 1",
-					Type: "custom",
-				},
-			},
-		}, nil)
-
-		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", utils.Anything).Return(nil)
-
-		err := th.App.moveBoardsToDefaultCategory("user_id", "team_id", "category_id_2")
-		assert.NoError(t, err)
-	})
-
-	t.Run("When default category doesn't already exists", func(t *testing.T) {
-		th.Store.EXPECT().GetUserCategoryBoards("user_id", "team_id").Return([]model.CategoryBoards{
-			{
-				Category: model.Category{
-					ID:   "category_id_2",
-					Name: "Custom Category 1",
-					Type: "custom",
-				},
-			},
-		}, nil)
-
-		th.Store.EXPECT().CreateCategory(utils.Anything).Return(nil)
-		th.Store.EXPECT().GetCategory(utils.Anything).Return(&model.Category{
-			ID:   "default_category_id",
-			Name: "Boards",
-			Type: "system",
-		}, nil)
-		th.Store.EXPECT().GetMembersForUser("user_id").Return([]*model.BoardMember{}, nil)
-		th.Store.EXPECT().GetBoardsForUserAndTeam("user_id", "team_id", false).Return([]*model.Board{}, nil)
-		th.Store.EXPECT().AddUpdateCategoryBoard("user_id", utils.Anything).Return(nil)
-
-		err := th.App.moveBoardsToDefaultCategory("user_id", "team_id", "category_id_2")
-		assert.NoError(t, err)
-	})
-}
-
-func TestReorderCategories(t *testing.T) {
-	th, tearDown := SetupTestHelper(t)
-	defer tearDown()
-
-	t.Run("base case", func(t *testing.T) {
-		th.Store.EXPECT().GetUserCategories("user_id", "team_id").Return([]model.Category{
-			{
-				ID:   "category_id_1",
-				Name: "Boards",
-				Type: "system",
-			},
-			{
-				ID:   "category_id_2",
-				Name: "Category 2",
-				Type: "custom",
-			},
-			{
-				ID:   "category_id_3",
-				Name: "Category 3",
-				Type: "custom",
-			},
-		}, nil)
-
-		th.Store.EXPECT().ReorderCategories("user_id", "team_id", []string{"category_id_2", "category_id_3", "category_id_1"}).
-			Return([]string{"category_id_2", "category_id_3", "category_id_1"}, nil)
-
-		newOrder, err := th.App.ReorderCategories("user_id", "team_id", []string{"category_id_2", "category_id_3", "category_id_1"})
-		assert.NoError(t, err)
-		assert.Equal(t, 3, len(newOrder))
-	})
-
-	t.Run("not specifying all categories should fail", func(t *testing.T) {
-		th.Store.EXPECT().GetUserCategories("user_id", "team_id").Return([]model.Category{
-			{
-				ID:   "category_id_1",
-				Name: "Boards",
-				Type: "system",
-			},
-			{
-				ID:   "category_id_2",
-				Name: "Category 2",
-				Type: "custom",
-			},
-			{
-				ID:   "category_id_3",
-				Name: "Category 3",
-				Type: "custom",
-			},
-		}, nil)
-
-		newOrder, err := th.App.ReorderCategories("user_id", "team_id", []string{"category_id_2", "category_id_3"})
-		assert.Error(t, err)
-		assert.Nil(t, newOrder)
-	})
-}
-
-func TestVerifyNewCategoriesMatchExisting(t *testing.T) {
-	th, tearDown := SetupTestHelper(t)
-	defer tearDown()
-
-	t.Run("base case", func(t *testing.T) {
-		th.Store.EXPECT().GetUserCategories("user_id", "team_id").Return([]model.Category{
-			{
-				ID:   "category_id_1",
-				Name: "Boards",
-				Type: "system",
-			},
-			{
-				ID:   "category_id_2",
-				Name: "Category 2",
-				Type: "custom",
-			},
-			{
-				ID:   "category_id_3",
-				Name: "Category 3",
-				Type: "custom",
-			},
-		}, nil)
-
-		err := th.App.verifyNewCategoriesMatchExisting("user_id", "team_id", []string{
-			"category_id_2",
-			"category_id_3",
-			"category_id_1",
-		})
-		assert.NoError(t, err)
-	})
-
-	t.Run("different category counts", func(t *testing.T) {
-		th.Store.EXPECT().GetUserCategories("user_id", "team_id").Return([]model.Category{
-			{
-				ID:   "category_id_1",
-				Name: "Boards",
-				Type: "system",
-			},
-			{
-				ID:   "category_id_2",
-				Name: "Category 2",
-				Type: "custom",
-			},
-			{
-				ID:   "category_id_3",
-				Name: "Category 3",
-				Type: "custom",
-			},
-		}, nil)
-
-		err := th.App.verifyNewCategoriesMatchExisting("user_id", "team_id", []string{
-			"category_id_2",
-			"category_id_3",
-		})
-		assert.Error(t, err)
-	})
-}

server/app/import_test.go

@@ -55,9 +55,8 @@ func TestApp_ImportArchive(t *testing.T) {
 			ID:   "boards_category_id",
 			Name: "Boards",
 		}, nil)
-		th.Store.EXPECT().GetBoardsForUserAndTeam("user", "test-team", false).Return([]*model.Board{}, nil)
 		th.Store.EXPECT().GetMembersForUser("user").Return([]*model.BoardMember{}, nil)
-		th.Store.EXPECT().AddUpdateCategoryBoard("user", utils.Anything).Return(nil)
+		th.Store.EXPECT().AddUpdateCategoryBoard("user", "boards_category_id", utils.Anything).Return(nil)
 
 		err := th.App.ImportArchive(r, opts)
 		require.NoError(t, err, "import archive should not fail")

server/app/onboarding_test.go

@@ -77,8 +77,7 @@ func TestPrepareOnboardingTour(t *testing.T) {
 			ID:   "boards_category",
 			Name: "Boards",
 		}, nil)
-		th.Store.EXPECT().GetBoardsForUserAndTeam("user_id_1", teamID, false).Return([]*model.Board{}, nil)
-		th.Store.EXPECT().AddUpdateCategoryBoard("user_id_1", map[string]string{"board_id_2": "boards_category_id"}).Return(nil)
+		th.Store.EXPECT().AddUpdateCategoryBoard("user_id_1", "boards_category_id", "board_id_2").Return(nil)
 
 		teamID, boardID, err := th.App.PrepareOnboardingTour(userID, teamID)
 		assert.NoError(t, err)
@@ -121,7 +120,7 @@ func TestCreateWelcomeBoard(t *testing.T) {
 				Category: model.Category{ID: "boards_category_id", Name: "Boards"},
 			},
 		}, nil).Times(2)
-		th.Store.EXPECT().AddUpdateCategoryBoard("user_id_1", map[string]string{"board_id_1": "boards_category_id"}).Return(nil)
+		th.Store.EXPECT().AddUpdateCategoryBoard("user_id_1", "boards_category_id", "board_id_1").Return(nil)
 
 		boardID, err := th.App.createWelcomeBoard(userID, teamID)
 		assert.Nil(t, err)